skip_input_data (j_decompress_ptr cinfo, long num_bytes)
{
iread_ptr src = (iread_ptr) cinfo->src;
if (num_bytes > 0) {
while (num_bytes > (long) src->pub.bytes_in_buffer) {
num_bytes -= (long) src->pub.bytes_in_buffer;
(void) fill_input_buffer(cinfo);
}
src->pub.next_input_byte += (size_t) num_bytes;
src->pub.bytes_in_buffer -= (size_t) num_bytes;
}
}
skip_input_data (j_decompress_ptr cinfo, long num_bytes)
{
#ifndef USE_SYMBIAN
my_src_ptr src = (my_src_ptr) cinfo->src;
/* Just a dumb implementation for now. Could use fseek() except
* it doesn't work on pipes. Not clear that being smart is worth
* any trouble anyway --- large skips are infrequent.
*/
if (num_bytes > 0) {
while (num_bytes > (long) src->pub.bytes_in_buffer) {
num_bytes -= (long) src->pub.bytes_in_buffer;
(void) fill_input_buffer(cinfo);
/* note we assume that fill_input_buffer will never return FALSE,
* so suspension need not be handled.
*/
}
src->pub.next_input_byte += (int) num_bytes;
src->pub.bytes_in_buffer -= (int) num_bytes;
}
#else
my_src_ptr src = (my_src_ptr) cinfo -> src;
if ( num_bytes > 0 )
{
src->pub.next_input_byte += (int) num_bytes;
src->pub.bytes_in_buffer -= (int) num_bytes;
}
#endif
}
bool decodeFillBuffer(std::string &error) {
for (;0 != strm.avail_out;) {
LOG_VERBOSE("decodeFillBuffer: %i bytes to go\n", (int) strm.avail_out);
if (!fill_input_buffer(error)) return false;
if (0 == strm.avail_in) {
error.assign("Unexpected end of file");
return false;
}
lzma_ret ret = lzma_code(&strm, LZMA_RUN);
if (LZMA_OK != ret && LZMA_STREAM_END != ret) {
errnoLzmaToStr("failed decoding data", ret, error);
return false;
}
if (0 == strm.avail_out) return true; // done filling buffer
if (LZMA_STREAM_END == ret) {
if (lzma_index_iter_next(&iter, LZMA_INDEX_ITER_ANY)) {
error.assign("Unexepected end of file");
return false;
}
/* restart decoder */
if (!loadBlock(error)) return false;
}
}
return true;
}
void speech_processor::process(sample_ptr samples,std::size_t count)
{
sample_ptr start=samples;
sample_ptr end=start+count;
while(fill_input_buffer(start,end))
{
on_input();
input.clear();
if(is_stopped())
return;
on_output();
if(is_stopped())
return;
if(!next)
continue;
if(!insertion.empty())
{
next->insert(&insertion[0],insertion.size());
insertion.clear();
if(is_stopped())
{
output.clear();
return;
}
}
if(output.empty())
continue;
next->process(&output[0],output.size());
output.clear();
if(is_stopped())
return;
}
}
bool decode(std::string &error) {
assert(0 != strm.avail_out);
const unsigned char *pos = strm.next_out;
for (;;) {
if (!fill_input_buffer(error)) return false;
if (0 == strm.avail_in) {
error.assign("Unexpected end of file");
return false;
}
lzma_ret ret = lzma_code(&strm, LZMA_RUN);
if (LZMA_OK != ret && LZMA_STREAM_END != ret) {
errnoLzmaToStr("failed decoding data", ret, error);
return false;
}
if (LZMA_STREAM_END == ret && pos == strm.next_out) {
/* end of stream AND we didn't get new data this round */
if (lzma_index_iter_next(&iter, LZMA_INDEX_ITER_ANY)) {
error.assign("Unexepected end of file");
return false;
}
/* restart decoder */
if (!loadBlock(error)) return false;
} else {
return true;
}
}
}
event_type JackProcessor::fill_output_buffer(int sequence_number)
{
if (m_sequence_number == sequence_number)
return 0;
m_sequence_number = sequence_number;
event_type events = fill_input_buffer(sequence_number);
generate_output();
events |= handle_memcpys();
return events;
}
skip_input_data (j_decompress_ptr cinfo, long num_bytes)
{
if (num_bytes > 0) {
while (num_bytes > (long) cinfo->src->bytes_in_buffer) {
num_bytes -= (long) cinfo->src->bytes_in_buffer;
(void) fill_input_buffer(cinfo);
}
cinfo->src->next_input_byte += (size_t) num_bytes;
cinfo->src->bytes_in_buffer -= (size_t) num_bytes;
}
}
static apr_status_t
read_lisp_line (apr_socket_t * socket, char * s, unsigned int len)
{
input_buffer_t * buffer;
char * scan_output = s;
char * end_output = (scan_output + (len - 1));
unsigned int n_pending_returns = 0;
RELAY_ERROR (get_input_buffer (socket, (&buffer)));
while (1)
{
if ((buffer->start) == (buffer->end))
RELAY_ERROR (fill_input_buffer (socket));
if ((buffer->start) > (buffer->end))
{
if (scan_output == s)
return (APR_EOF);
goto done;
}
while (((buffer->start) < (buffer->end)) && (scan_output < end_output))
{
char c = (*(buffer->start)++);
if (c == '\n')
{
if (n_pending_returns > 0)
n_pending_returns -= 1;
goto done;
}
if (c == '\r')
n_pending_returns += 1;
else
{
while ((n_pending_returns > 0) && (scan_output < end_output))
{
(*scan_output++) = '\r';
n_pending_returns -= 1;
}
if (scan_output == end_output)
goto done;
(*scan_output++) = c;
}
}
}
done:
while ((n_pending_returns > 0) && (scan_output < end_output))
{
(*scan_output++) = '\r';
n_pending_returns -= 1;
}
(*scan_output) = '\0';
return (APR_SUCCESS);
}
static void skip_input_data(j_decompress_ptr jd, long num_bytes)
{
struct src_mgr *src = (struct src_mgr*)jd->src;
if(num_bytes > 0) {
while(num_bytes > (long)src->pub.bytes_in_buffer) {
num_bytes -= (long)src->pub.bytes_in_buffer;
fill_input_buffer(jd);
}
src->pub.next_input_byte += (size_t)num_bytes;
src->pub.bytes_in_buffer -= (size_t)num_bytes;
}
}
skip_input_data (j_decompress_ptr cinfo, long num_bytes)
{
byte_stream_src_ptr src = (byte_stream_src_ptr) cinfo->src;
if (num_bytes > (long) src->pub.bytes_in_buffer)
{
src->byteStream->seek((num_bytes - src->pub.bytes_in_buffer), SEEK_CUR);
(void) fill_input_buffer(cinfo);
}else
{
src->pub.bytes_in_buffer -= num_bytes;
src->pub.next_input_byte += num_bytes;
}
}
void skip_input_data (j_decompress_ptr cinfo,
long num_bytes)
{
if(num_bytes > 0) {
if (num_bytes < cinfo->src->bytes_in_buffer) {
cinfo->src->next_input_byte += num_bytes;
cinfo->src->bytes_in_buffer -= num_bytes;
}
else {
fill_input_buffer(cinfo);
}
}
}
void ImporterImageJPG::skip_input_data (j_decompress_ptr cinfo, long num_bytes)
{
ImportSource *src = (ImportSource *) cinfo->src;
if (num_bytes > 0) {
while (num_bytes > (long) src->pub.bytes_in_buffer) {
num_bytes -= (long) src->pub.bytes_in_buffer;
fill_input_buffer(cinfo);
}
src->pub.next_input_byte += (size_t) num_bytes;
src->pub.bytes_in_buffer -= (size_t) num_bytes;
}
}
bool loadBlock(std::string &error) {
clearFilters();
position = -1;
//LOG_VERBOSE("seeking to offset %i", (int) iter->block.compressed_file_offset);
reader.seek(iter.block.compressed_file_offset);
strm.avail_in = 0; /* make sure we read new data after lseek */
if (!fill_input_buffer(error)) return false;
if (0 == strm.avail_in) {
error.assign("Unexpected end of file while trying to read block header");
return false;
}
block.version = 0;
block.check = iter.stream.flags->check;
block.header_size = lzma_block_header_size_decode(strm.next_in[0]);
if (block.header_size > strm.avail_in) {
error.assign("Unexpected end of file while trying to read block header");
return false;
}
// Decode the Block Header.
lzma_ret ret = lzma_block_header_decode(&block, NULL, strm.next_in);
if (LZMA_OK != ret) {
errnoLzmaToStr("decoding block header failed", ret, error);
return false;
}
ret = lzma_block_compressed_size(&block, iter.block.unpadded_size);
if (LZMA_OK != ret) {
errnoLzmaToStr("decoding block header failed, invalid compressed size", ret, error);
return false;
}
strm.next_in += block.header_size;
strm.avail_in -= block.header_size;
lzma_end(&strm);
ret = lzma_block_decoder(&strm, &block);
if (LZMA_OK != ret) {
errnoLzmaToStr("couldn't initialize block decoder", ret, error);
return false;
}
position = iter.block.uncompressed_file_offset;
return true;
}
static void
skip_input_data(j_decompress_ptr cinfo, long num_bytes)
{
struct my_src_mgr *src = (void *)cinfo->src;
if (num_bytes > 0)
{
while (num_bytes > (long)src->pub.bytes_in_buffer)
{
num_bytes -= (long)src->pub.bytes_in_buffer;
fill_input_buffer(cinfo);
}
}
src->pub.next_input_byte += num_bytes;
src->pub.bytes_in_buffer -= num_bytes;
}
void skip_input_data (j_decompress_ptr cinfo, long nbytes)
{
digikam_source_mgr* src = (digikam_source_mgr*) cinfo->src;
if (nbytes > 0)
{
while (nbytes > (long) src->pub.bytes_in_buffer)
{
nbytes -= (long) src->pub.bytes_in_buffer;
(void) fill_input_buffer(cinfo);
}
src->pub.next_input_byte += (size_t) nbytes;
src->pub.bytes_in_buffer -= (size_t) nbytes;
}
}
skip_input_data (j_decompress_ptr cinfo, long num_bytes)
{
my_src_ptr src = (my_src_ptr) cinfo->src;
if (num_bytes > 0) {
while (num_bytes > (long) src->pub.bytes_in_buffer) {
num_bytes -= (long) src->pub.bytes_in_buffer;
(void) fill_input_buffer(cinfo);
/* note we assume that fill_input_buffer will never
* return FALSE, so suspension need not be handled.
*/
}
src->pub.next_input_byte += (size_t) num_bytes;
src->pub.bytes_in_buffer -= (size_t) num_bytes;
}
}
fill_input_buffer_ipp (j_decompress_ptr cinfo)
{
my_src_ptr src = (my_src_ptr) cinfo->src;
size_t bytes_left = src->pub.bytes_in_buffer;
size_t bytes_to_read = INPUT_BUF_SIZE - bytes_left;
if(src->start_of_file || cinfo->progressive_mode)
{
return fill_input_buffer(cinfo);
}
memmove(src->buffer,src->pub.next_input_byte,bytes_left);
size_t nbytes
= VSIFReadL(src->buffer + bytes_left, 1, bytes_to_read, src->infile);
if(nbytes <= 0)
{
if(src->start_of_file)
{
/* Treat empty input file as fatal error */
ERREXIT(cinfo, JERR_INPUT_EMPTY);
}
if(src->pub.bytes_in_buffer == 0 && cinfo->unread_marker == 0)
{
WARNMS(cinfo, JWRN_JPEG_EOF);
/* Insert a fake EOI marker */
src->buffer[0] = (JOCTET)0xFF;
src->buffer[1] = (JOCTET)JPEG_EOI;
nbytes = 2;
}
src->pub.next_input_byte = src->buffer;
src->pub.bytes_in_buffer = bytes_left + nbytes;
src->start_of_file = FALSE;
return TRUE;
}
src->pub.next_input_byte = src->buffer;
src->pub.bytes_in_buffer = bytes_left + nbytes;
src->start_of_file = FALSE;
return TRUE;
}
// Called by client when it wants to advance past some
// uninteresting data.
static void skip_input_data(j_decompress_ptr cinfo, long num_bytes)
{
rw_source_IOChannel* src = (rw_source_IOChannel*) cinfo->src;
// According to jpeg docs, large skips are
// infrequent. So let's just do it the simple
// way.
if (num_bytes > 0) {
while (num_bytes > static_cast<long>(src->m_pub.bytes_in_buffer)) {
num_bytes -= static_cast<long>(src->m_pub.bytes_in_buffer);
fill_input_buffer(cinfo);
}
// Handle remainder.
src->m_pub.next_input_byte += (size_t) num_bytes;
src->m_pub.bytes_in_buffer -= (size_t) num_bytes;
}
}
/**
Signature dictated by IJG.
*/
static void skip_input_data(
j_decompress_ptr cinfo,
long num_bytes) {
mem_src_ptr src = (mem_src_ptr)cinfo->src;
if (num_bytes > 0) {
while (num_bytes > (long) src->pub.bytes_in_buffer) {
num_bytes -= (long) src->pub.bytes_in_buffer;
boolean s = fill_input_buffer(cinfo);
debugAssert(s); (void)s;
}
src->pub.next_input_byte += (size_t) num_bytes;
src->pub.bytes_in_buffer -= (size_t) num_bytes;
}
}
static void skip_input_data(j_decompress_ptr cinfo, long num_bytes)
// Called by client when it wants to advance past some
// uninteresting data.
{
rw_source* src = (rw_source*) cinfo->src;
// According to jpeg docs, large skips are
// infrequent. So let's just do it the simple
// way.
if (num_bytes > 0) {
while (num_bytes > (long) src->m_pub.bytes_in_buffer) {
num_bytes -= (long) src->m_pub.bytes_in_buffer;
fill_input_buffer(cinfo);
}
// Handle remainder.
src->m_pub.next_input_byte += (size_t) num_bytes;
src->m_pub.bytes_in_buffer -= (size_t) num_bytes;
}
}
void skip_input_data(j_decompress_ptr cinfo, long num_bytes)
{
my_src_ptr src = (my_src_ptr)cinfo->src;
/* Just a dumb implementation for now. Not clear that being smart is worth
* any trouble anyway --- large skips are infrequent.
*/
if(num_bytes > 0) {
while(num_bytes > (long)src->pub.bytes_in_buffer) {
num_bytes -= (long)src->pub.bytes_in_buffer;
(void)fill_input_buffer(cinfo);
/* note we assume that fill_input_buffer will never return FALSE,
* so suspension need not be handled.
*/
}
src->pub.next_input_byte += (size_t)num_bytes;
src->pub.bytes_in_buffer -= (size_t)num_bytes;
}
}
template <class charT, class traits> inline
std::streamsize
basic_unzip_streambuf<charT, traits>::unzip_from_stream(char_type* buffer,
std::streamsize buffer_size)
{
_zip_stream.next_out =
(byte_buffer_type) buffer;
_zip_stream.avail_out =
static_cast<uInt>(buffer_size * sizeof(char_type));
size_t count = _zip_stream.avail_in;
do
{
if(_zip_stream.avail_in == 0)
count=fill_input_buffer();
if(_zip_stream.avail_in)
{
_err = inflate(&_zip_stream, Z_SYNC_FLUSH);
}
}
while(_err==Z_OK && _zip_stream.avail_out != 0 && count != 0);
std::streamsize theSize = buffer_size - ((std::streamsize)_zip_stream.avail_out) / sizeof(char_type);
// assert (theSize >= 0 && theSize < std::numeric_limits<uInt>::max());
// updating crc
_crc = crc32(_crc, (byte_buffer_type) buffer,(uInt)theSize);
std::streamsize n_read =
buffer_size - _zip_stream.avail_out / sizeof(char_type);
// check if it is the end
if (_err == Z_STREAM_END)
put_back_from_zip_stream();
return n_read;
}
/**
* \brief Skip some bytes in the input buffer.
* \param num_bytes The number of bytes to skip.
*/
void
claw::graphic::jpeg::reader::source_manager::skip_input_data(long num_bytes)
{
CLAW_PRECOND(num_bytes >=0);
if ( (size_t)num_bytes <= pub.bytes_in_buffer )
{
pub.next_input_byte += num_bytes;
pub.bytes_in_buffer -= num_bytes;
}
else
{
num_bytes -= pub.bytes_in_buffer;
long div = num_bytes / m_buffer_size;
long rest = num_bytes % m_buffer_size;
for (long i=0; i!=(div+1); ++i)
fill_input_buffer();
pub.next_input_byte += rest;
pub.bytes_in_buffer -= rest;
}
} // jpeg::reader::source_manager::skip_input_data()
void init_source(j_decompress_ptr cinfo)
{
fill_input_buffer(cinfo);
}
static int
lisp_handler (request_rec * r)
{
lisp_cfg_t * cfg
= (ap_get_module_config ((r->per_dir_config), (&lisp_module)));
int content_length = (-1);
int keep_socket_p = 0;
apr_socket_t * socket;
const char * request_content_length = 0;
cfg = local_lisp_cfg(cfg);
if ((strcmp ((r->handler), "lisp-handler")) != 0)
return (DECLINED);
/* Open a connection to the Lisp process. */
ML_LOG_DEBUG (r, "open lisp connection");
CVT_ERROR ((open_lisp_socket (cfg)), "opening connection to Lisp");
(SERVER_SOCKET_SAFE_P (cfg)) = 0;
socket = (SERVER_SOCKET (cfg));
/* Remove any timeout that might be left over from earlier. */
ML_LOG_DEBUG (r, "clear socket timeout");
CVT_ERROR ((apr_socket_timeout_set (socket, (-1))), "clearing read timeout");
/* Convert environment variables to headers and send them. */
ML_LOG_DEBUG (r, "write env-var headers");
ap_add_cgi_vars (r);
ap_add_common_vars (r);
if ((r->subprocess_env) != 0)
CVT_ERROR
((copy_headers
((r->subprocess_env), map_env_var_to_lisp_header, socket)),
"writing to Lisp");
/* Send this before client headers so ASSOC can be used to grab it
without worrying about some joker sending a server-id header of
his own. (Robert Macomber) */
ML_LOG_DEBUG (r, "write headers");
CVT_ERROR ((write_lisp_header (socket, "server-id", (cfg->server_id))),
"writing to Lisp");
CVT_ERROR ((write_lisp_header (socket, "server-baseversion", AP_SERVER_BASEVERSION)),
"writing to Lisp");
CVT_ERROR ((write_lisp_header (socket, "modlisp-version", VERSION_STRING)),
"writing to Lisp");
CVT_ERROR ((write_lisp_header (socket, "modlisp-major-version", "2")),
"writing to Lisp");
/* Send all the remaining headers. */
if ((r->headers_in) != 0)
CVT_ERROR
((copy_headers ((r->headers_in), map_header_to_lisp_header, socket)),
"writing to Lisp");
request_content_length = apr_table_get(r->headers_in, "Content-Length");
/* Send the end-of-headers marker. */
ML_LOG_DEBUG (r, "write end-of-headers");
CVT_ERROR ((write_lisp_line (socket, "end")), "writing to Lisp");
/* Send the request entity. */
RELAY_HTTP_ERROR (ap_setup_client_block (r, REQUEST_CHUNKED_DECHUNK));
if (ap_should_client_block (r))
{
char buffer [4096];
ML_LOG_DEBUG (r, "write entity");
while (1)
{
long n_read = (ap_get_client_block (r, buffer, (sizeof (buffer))));
if (n_read < 0)
{
ML_LOG_PERROR (r, "error reading from client");
close_lisp_socket (cfg);
return (HTTP_INTERNAL_SERVER_ERROR);
}
/* for chunked case, when nread == 0, we will write
* a terminating 0.*/
{
apr_status_t status = APR_SUCCESS;
/* if there's no Content-Type header, the data must be chunked */
if (request_content_length == NULL)
status = write_lisp_data_chunk (socket, buffer, n_read);
else if (n_read != 0)
status = write_lisp_data (socket, buffer, n_read);
if (APR_SUCCESS != status)
{
while ((ap_get_client_block (r, buffer, sizeof(buffer)))
> 0)
;
ML_LOG_ERROR (status, r, "writing to Lisp");
close_lisp_socket (cfg);
return (HTTP_INTERNAL_SERVER_ERROR);
}
}
if( n_read == 0)
break;
}
}
/* Set up read timeout so we don't hang forever if Lisp is wedged. */
ML_LOG_DEBUG (r, "set socket timeout");
CVT_ERROR ((apr_socket_timeout_set (socket, READ_TIMEOUT)),
"setting read timeout");
/* Read the headers and process them. */
ML_LOG_DEBUG (r, "read headers");
while (1)
{
char header_name [4096];
char header_value [MAX_STRING_LEN];
CVT_ERROR
((read_lisp_line (socket, header_name, (sizeof (header_name)))),
"reading from Lisp");
if ((strcasecmp (header_name, "end")) == 0)
break;
CVT_ERROR
((read_lisp_line (socket, header_value, (sizeof (header_value)))),
"reading from Lisp");
if ((strcasecmp (header_name, "content-type")) == 0)
{
char * tmp = (apr_pstrdup ((r->pool), header_value));
ap_content_type_tolower (tmp);
(r->content_type) = tmp;
}
else if ((strcasecmp (header_name, "status")) == 0)
{
(r->status) = (atoi (header_value));
(r->status_line) = (apr_pstrdup ((r->pool), header_value));
}
else if ((strcasecmp (header_name, "location")) == 0)
apr_table_set ((r->headers_out), header_name, header_value);
else if ((strcasecmp (header_name, "content-length")) == 0)
{
apr_table_set ((r->headers_out), header_name, header_value);
content_length = (atoi (header_value));
}
else if ((strcasecmp (header_name, "lisp-content-length")) == 0)
{
content_length = (atoi (header_value));
}
else if ((strcasecmp (header_name, "last-modified")) == 0)
{
apr_time_t mtime = (apr_date_parse_http (header_value));
r->mtime = mtime;
ap_set_last_modified (r);
}
else if ((strcasecmp (header_name, "keep-socket")) == 0)
keep_socket_p = (atoi (header_value));
else if ((strcasecmp (header_name, "log-emerg")) == 0)
ap_log_error (APLOG_MARK, APLOG_EMERG, APR_SUCCESS, (r->server),
"%s", header_value);
else if ((strcasecmp (header_name, "log-alert")) == 0)
ap_log_error (APLOG_MARK, APLOG_ALERT, APR_SUCCESS, (r->server),
"%s", header_value);
else if ((strcasecmp (header_name, "log-crit")) == 0)
ap_log_error (APLOG_MARK, APLOG_CRIT, APR_SUCCESS, (r->server),
"%s", header_value);
else if ((strcasecmp (header_name, "log-error")) == 0)
ap_log_error (APLOG_MARK, APLOG_ERR, APR_SUCCESS, (r->server),
"%s", header_value);
else if ((strcasecmp (header_name, "log-warning")) == 0)
ap_log_error (APLOG_MARK, APLOG_WARNING, APR_SUCCESS, (r->server),
"%s", header_value);
else if ((strcasecmp (header_name, "log-notice")) == 0)
ap_log_error (APLOG_MARK, APLOG_NOTICE, APR_SUCCESS, (r->server),
"%s", header_value);
else if ((strcasecmp (header_name, "log-info")) == 0)
ap_log_error (APLOG_MARK, APLOG_INFO, APR_SUCCESS, (r->server),
"%s", header_value);
else if ((strcasecmp (header_name, "log-debug")) == 0)
ap_log_error (APLOG_MARK, APLOG_DEBUG, APR_SUCCESS, (r->server),
"%s", header_value);
else if ((strcasecmp (header_name, "log")) == 0)
ap_log_error (APLOG_MARK, APLOG_ERR, APR_SUCCESS, (r->server),
"%s", header_value);
else if ((strcasecmp (header_name, "note")) == 0)
{
char * p = (strchr (header_value, ' '));
if (p != 0)
{
(*p++) = '\0';
apr_table_setn ((r->notes),
(apr_pstrdup ((r->pool), header_value)),
(apr_pstrdup ((r->pool), p)));
}
}
else if ((strcasecmp (header_name, "set-cookie")) == 0)
{
apr_table_add ((r->headers_out), header_name, header_value);
}
else
apr_table_set ((r->headers_out), header_name, header_value);
}
/* Copy the reply entity from Lisp to the client... */
// if (content_length > 0)
{
unsigned int n_read = 0;
input_buffer_t * buffer;
ML_LOG_DEBUG (r, "read entity");
CVT_ERROR ((get_input_buffer (socket, (&buffer))), "reading from Lisp");
while ((buffer->start) <= (buffer->end))
{
apr_status_t fill_status;
unsigned int n_bytes = ((buffer->end) - (buffer->start));
n_read += n_bytes;
if ((content_length >= 0) && (n_read > content_length))
{
n_bytes -= (n_read - content_length);
n_read -= (n_read - content_length);
}
/* ...unless it's a HEAD request. */
if (!r->header_only && !write_client_data (r, (buffer->start), n_bytes))
{
close_lisp_socket (cfg);
return (HTTP_INTERNAL_SERVER_ERROR);
}
(buffer->start) += n_bytes;
if (n_read == content_length)
break;
fill_status = fill_input_buffer (socket);
if ((fill_status == APR_EOF) && (content_length < 0))
break;
else
CVT_ERROR (fill_status, "reading from Lisp");
}
}
if ((content_length < 0) || (!keep_socket_p))
CVT_ERROR ((close_lisp_socket (cfg)), "closing connection to Lisp");
else
(SERVER_SOCKET_SAFE_P (cfg)) = 1;
ML_LOG_DEBUG (r, "request finished");
return (OK);
}
