void
JAWS_Synch_IO::receive_file (JAWS_IO_Handler *ioh,
const char *filename,
void *initial_data,
unsigned int initial_data_length,
unsigned int entire_length)
{
ACE_Filecache_Handle handle (filename,
(int) entire_length);
int result = handle.error ();
if (result == ACE_Filecache_Handle::ACE_SUCCESS)
{
ACE_SOCK_Stream stream;
stream.set_handle (ioh->handle ());
int bytes_to_memcpy = ACE_MIN (entire_length, initial_data_length);
ACE_OS::memcpy (handle.address (), initial_data, bytes_to_memcpy);
int bytes_to_read = entire_length - bytes_to_memcpy;
int bytes = stream.recv_n ((char *)
handle.address () + initial_data_length,
bytes_to_read);
if (bytes == bytes_to_read)
ioh->receive_file_complete ();
else
result = -1;
}
if (result != ACE_Filecache_Handle::ACE_SUCCESS)
ioh->receive_file_error (result);
}
void
JAWS_Synch_IO::receive_file (const char *filename,
void *initial_data,
int initial_data_length,
int entire_length)
{
ACE_Filecache_Handle handle (ACE_TEXT_CHAR_TO_TCHAR (filename), entire_length);
int result = handle.error ();
if (result == ACE_Filecache_Handle::ACE_SUCCESS)
{
ACE_SOCK_Stream stream;
stream.set_handle (this->handle_);
int bytes_to_memcpy = ACE_MIN (entire_length, initial_data_length);
ACE_OS::memcpy (handle.address (), initial_data, bytes_to_memcpy);
int bytes_to_read = entire_length - bytes_to_memcpy;
int bytes = stream.recv_n ((char *) handle.address () + initial_data_length,
bytes_to_read);
if (bytes == bytes_to_read)
this->handler_->receive_file_complete ();
else
result = -1;
}
if (result != ACE_Filecache_Handle::ACE_SUCCESS)
this->handler_->receive_file_error (result);
}
void
JAWS_Synch_IO::transmit_file (const char *filename,
const char *header,
int header_size,
const char *trailer,
int trailer_size)
{
ACE_Filecache_Handle handle (ACE_TEXT_CHAR_TO_TCHAR (filename));
int result = handle.error ();
if (result == ACE_Filecache_Handle::ACE_SUCCESS)
{
#if defined (ACE_JAWS_BASELINE) || defined (ACE_WIN32)
ACE_SOCK_Stream stream;
stream.set_handle (this->handle_);
if ((stream.send_n (header, header_size) == header_size)
&& (stream.send_n (handle.address (), handle.size ())
== handle.size ())
&& (stream.send_n (trailer, trailer_size) == trailer_size))
this->handler_->transmit_file_complete ();
else
result = -1;
#else
// Attempting to use writev
// Is this faster?
iovec iov[3];
int iovcnt = 0;
if (header_size > 0)
{
iov[iovcnt].iov_base = const_cast<char*> (header);
iov[iovcnt].iov_len = header_size;
iovcnt++;
}
if (handle.size () > 0)
{
iov[iovcnt].iov_base = reinterpret_cast<char*> (handle.address ());
iov[iovcnt].iov_len = handle.size ();
iovcnt++;
}
if (trailer_size > 0)
{
iov[iovcnt].iov_base = const_cast<char*> (trailer);
iov[iovcnt].iov_len = trailer_size;
iovcnt++;
}
if (ACE_OS::writev (this->handle_, iov, iovcnt) < 0)
result = -1;
else
this->handler_->transmit_file_complete ();
#endif /* ACE_JAWS_BASELINE */
}
if (result != ACE_Filecache_Handle::ACE_SUCCESS)
this->handler_->transmit_file_error (result);
}
void
JAWS_Asynch_IO::receive_file (JAWS_IO_Handler *ioh,
const char *filename,
void *initial_data,
unsigned int initial_data_length,
unsigned int entire_length)
{
JAWS_TRACE ("JAWS_Asynch_IO::receive_file");
ioh->idle ();
JAWS_Asynch_IO_Handler *aioh =
dynamic_cast<JAWS_Asynch_IO_Handler *> (ioh);
ACE_Message_Block *mb = 0;
ACE_Filecache_Handle *handle;
ACE_NEW (handle, ACE_Filecache_Handle (filename, entire_length, ACE_NOMAP));
int result = handle->error ();
if (result == ACE_Filecache_Handle::ACE_SUCCESS)
{
ACE_OS::memcpy (handle->address (),
initial_data,
initial_data_length);
int bytes_to_read = entire_length - initial_data_length;
ACE_NEW (mb, ACE_Message_Block ((char *)handle->address ()
+ initial_data_length, bytes_to_read));
if (mb == 0)
{
errno = ENOMEM;
result = -1;
}
else
{
ACE_Asynch_Read_Stream ar;
if (ar.open (*(aioh->handler ()), aioh->handle ()) == -1
|| ar.read (*mb, mb->size () - mb->length (), handle) == -1)
result = -1;
}
}
if (result != ACE_Filecache_Handle::ACE_SUCCESS)
{
this->handler_->receive_file_error (result);
delete mb;
delete handle;
}
}
void
JAWS_Asynch_IO::transmit_file (const char *filename,
const char *header,
int header_size,
const char *trailer,
int trailer_size)
{
ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer = 0;
ACE_Filecache_Handle *handle = new ACE_Filecache_Handle (filename, ACE_NOMAP);
int result = handle->error ();
if (result == ACE_Filecache_Handle::ACE_SUCCESS)
{
ACE_Message_Block header_mb (header, header_size);
ACE_Message_Block trailer_mb (trailer, trailer_size);
header_and_trailer = new ACE_Asynch_Transmit_File::Header_And_Trailer
(&header_mb, header_size, &trailer_mb, trailer_size);
ACE_Asynch_Transmit_File tf;
if (tf.open (*this, this->handle_) == -1
|| tf.transmit_file (handle->handle (), // file handle
header_and_trailer, // header and trailer data
0, // bytes_to_write
0, // offset
0, // offset_high
0, // bytes_per_send
0, // flags
handle // act
) == -1)
result = -1;
}
if (result != ACE_Filecache_Handle::ACE_SUCCESS)
{
this->handler_->transmit_file_error (result);
delete header_and_trailer;
delete handle;
}
}