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_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_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::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;
}
}
int
HTTP_Handler::svc (void)
{
static char buf[BUFSIZ];
int count = 0;
ACE_DEBUG ((LM_DEBUG, "[%t] sending request --\n%s", this->request_));
this->peer ().send_n (this->request_, this->request_size_);
// Read in characters until encounter \r\n\r\n
int done = 0;
char *contentlength;
do
{
while (((count += this->peer ().recv_n (buf + count, 1)) > 0)
&& ((u_int) count < sizeof (buf)))
{
buf[count] = '\0';
if (count < 2)
continue;
done = ACE_OS::strcmp (buf + count - 4, "\n\n") == 0;
if (done)
break;
if (count < 4)
continue;
done = ACE_OS::strcmp (buf + count - 4, "\r\n\r\n") == 0;
if (done)
break;
}
if (!done)
{
char *last = ACE_OS::strrchr (buf, '\n');
last[0] = '\0';
if ((contentlength = ACE_OS::strstr (buf, "\nContent-length:"))
|| (contentlength = ACE_OS::strstr (buf, "\nContent-Length:")))
done = 1;
else
{
last[0] = '\n';
count = ACE_OS::strlen (last);
ACE_OS::memmove (buf, last, count + 1);
}
}
else
{
contentlength = ACE_OS::strstr (buf, "\nContent-length:");
if (!contentlength)
contentlength =
ACE_OS::strstr (buf, "\nContent-Length:");
}
}
while (!done);
// ASSERT (contentlength != 0)
int size = 0;
if (contentlength
&& (::sscanf (contentlength, "\nContent-%*[lL]ength: %d ",
&size) == 1))
{
this->response_size_ = size;
ACE_Filecache_Handle afh (ACE_TEXT_CHAR_TO_TCHAR (this->filename_),
this->response_size_);
this->peer ().recv_n (afh.address (), this->response_size_);
ACE_DEBUG ((LM_DEBUG,
" ``%s'' is now cached.\n",
this->filename_));
}
else
{
// Maybe we should do something more clever here, such as extend
// ACE_Filecache_Handle to allow the creation of cache objects
// whose size is unknown?
// Another possibility is to write the contents out to a file,
// and then cache it.
// Perhaps make ACE_Filecache_Handle more savvy, and allow a
// constructor which accepts a PEER as a parameter.
ACE_DEBUG ((LM_DEBUG,
"HTTP_Handler, no content-length header!\n"));
}
return 0;
}