//virtual
LLIOPipe::EStatus LLPipeStringInjector::process_impl(
const LLChannelDescriptors& channels,
buffer_ptr_t& buffer,
bool& eos,
LLSD& context,
LLPumpIO* pump)
{
buffer->append(channels.out(), (U8*) mString.data(), mString.size());
eos = true;
return STATUS_DONE;
}
// virtual
LLIOPipe::EStatus LLIOASCIIFuzz::process_impl(
const LLChannelDescriptors& channels,
buffer_ptr_t& buffer,
bool& eos,
LLSD& context,
LLPumpIO* pump)
{
while(mByteCount)
{
std::vector<U8> data;
data.reserve(10000);
int size = llmin(10000, mByteCount);
std::generate_n(
std::back_insert_iterator< std::vector<U8> >(data),
size,
random_ascii_generator());
buffer->append(channels.out(), &data[0], size);
mByteCount -= size;
}
return STATUS_OK;
}
// virtual
LLIOPipe::EStatus LLIOSocketReader::process_impl(
const LLChannelDescriptors& channels,
buffer_ptr_t& buffer,
bool& eos,
LLSD& context,
LLPumpIO* pump)
{
LL_RECORD_BLOCK_TIME(FTM_PROCESS_SOCKET_READER);
PUMP_DEBUG;
if(!mSource) return STATUS_PRECONDITION_NOT_MET;
if(!mInitialized)
{
PUMP_DEBUG;
// Since the read will not block, it's ok to initialize and
// attempt to read off the descriptor immediately.
mInitialized = true;
if(pump)
{
PUMP_DEBUG;
LL_DEBUGS() << "Initializing poll descriptor for LLIOSocketReader."
<< LL_ENDL;
apr_pollfd_t poll_fd;
poll_fd.p = NULL;
poll_fd.desc_type = APR_POLL_SOCKET;
poll_fd.reqevents = APR_POLLIN;
poll_fd.rtnevents = 0x0;
poll_fd.desc.s = mSource->getSocket();
poll_fd.client_data = NULL;
pump->setConditional(this, &poll_fd);
}
}
//if(!buffer)
//{
// buffer = new LLBufferArray;
//}
PUMP_DEBUG;
const apr_size_t READ_BUFFER_SIZE = 1024;
char read_buf[READ_BUFFER_SIZE]; /*Flawfinder: ignore*/
apr_size_t len;
apr_status_t status = APR_SUCCESS;
do
{
PUMP_DEBUG;
len = READ_BUFFER_SIZE;
status = apr_socket_recv(mSource->getSocket(), read_buf, &len);
buffer->append(channels.out(), (U8*)read_buf, len);
} while((APR_SUCCESS == status) && (READ_BUFFER_SIZE == len));
LL_DEBUGS() << "socket read status: " << status << LL_ENDL;
LLIOPipe::EStatus rv = STATUS_OK;
PUMP_DEBUG;
// *FIX: Also need to check for broken pipe
if(APR_STATUS_IS_EOF(status))
{
// *FIX: Should we shut down the socket read?
if(pump)
{
pump->setConditional(this, NULL);
}
rv = STATUS_DONE;
eos = true;
}
else if(APR_STATUS_IS_EAGAIN(status))
{
/*Commented out by Aura 9-9-8 for DEV-19961.
// everything is fine, but we can terminate this process pump.
rv = STATUS_BREAK;
*/
}
else
{
if(ll_apr_warn_status(status))
{
rv = STATUS_ERROR;
}
}
PUMP_DEBUG;
return rv;
}
// virtual
LLIOPipe::EStatus LLSDRPCClient::process_impl(
const LLChannelDescriptors& channels,
buffer_ptr_t& buffer,
bool& eos,
LLSD& context,
LLPumpIO* pump)
{
PUMP_DEBUG;
LLMemType m1(LLMemType::MTYPE_IO_SD_CLIENT);
if((STATE_NONE == mState) || (!pump))
{
// You should have called the call() method already.
return STATUS_PRECONDITION_NOT_MET;
}
EStatus rv = STATUS_DONE;
switch(mState)
{
case STATE_READY:
{
PUMP_DEBUG;
// lldebugs << "LLSDRPCClient::process_impl STATE_READY" << llendl;
buffer->append(
channels.out(),
(U8*)mRequest.c_str(),
mRequest.length());
context[CONTEXT_DEST_URI_SD_LABEL] = mURI;
mState = STATE_WAITING_FOR_RESPONSE;
break;
}
case STATE_WAITING_FOR_RESPONSE:
{
PUMP_DEBUG;
// The input channel has the sd response in it.
//lldebugs << "LLSDRPCClient::process_impl STATE_WAITING_FOR_RESPONSE"
// << llendl;
LLBufferStream resp(channels, buffer.get());
LLSD sd;
LLSDSerialize::fromNotation(sd, resp, buffer->count(channels.in()));
LLSDRPCResponse* response = (LLSDRPCResponse*)mResponse.get();
if (!response)
{
mState = STATE_DONE;
break;
}
response->extractResponse(sd);
if(EPBQ_PROCESS == mQueue)
{
LLPumpIO::chain_t chain;
chain.push_back(mResponse);
pump->addChain(chain, DEFAULT_CHAIN_EXPIRY_SECS);
}
else
{
pump->respond(mResponse.get());
}
mState = STATE_DONE;
break;
}
case STATE_DONE:
default:
PUMP_DEBUG;
llinfos << "invalid state to process" << llendl;
rv = STATUS_ERROR;
break;
}
return rv;
}