int Sessionx::rd_stream()
{
int result = 0;
LOG_INPUT_MSG_SIZE();
m_inputs.crunch();
LOG_INPUT_MSG_SIZE();
int recv_n = (int)this->peer().recv(m_inputs.wr_ptr(), m_inputs.space());
if (recv_n > 0)
{
m_save_input_pack_info.save(m_inputs.wr_ptr(), recv_n);
LOG_INPUT_MSG_SIZE();
m_inputs.wr_ptr(recv_n);
LOG_INPUT_MSG_SIZE();
parseInputPacket();
}
else if (0 == recv_n)
{
// remote normal close
//DEF_LOG_ERROR("remote stream close normally, last error is <%d>\n", ACE_OS::last_error());
//string debug_str = "remote stream close normally, last error is : " + boost::lexical_cast<string>(ACE_OS::last_error()) + " buffer length : " + boost::lexical_cast<string>(m_inputs.space()) + "\n";
//std::cout << debug_str;
recvError(recv_n, ACE_OS::last_error());
result = -1;
}
else
{
int last_error = ACE_OS::last_error();
if ((last_error == EWOULDBLOCK) || (last_error == EINTR) || (last_error == EAGAIN))
{
// ok, no data in session
}
else
{
//DEF_LOG_ERROR("occur error while send data, return value is <%d>, last error is <%d>\n", recv_n, last_error);
//string debug_str = "occur error while send data, return value is : " + boost::lexical_cast<string>(recv_n) + " last error is : " + boost::lexical_cast<string>(ACE_OS::last_error()) + "\n";
//std::cout << debug_str;
recvError(recv_n, ACE_OS::last_error());
result = -1;
}
}
return result;
}
static void trfs_recv_thread(void *arg)
{
(void) arg;
u_int8_t buf[TRFS_MAX_PKT];
t_current_set_name("TRFS Recv");
while(connect_trfs())
{
SHOW_ERROR0( 1, "Unable to connect" );
hal_sleep_msec(20000);
//return;
}
while(1)
{
int rc;
if( ( rc = trfs_recv( &buf, TRFS_MAX_PKT)) <= 0 )
{
SHOW_ERROR( 1, "recv err %d", rc );
again:
hal_sleep_msec( 100 ); // Against tight loop
continue;
}
if( rc < (int)sizeof(trfs_pkt_t) )
{
SHOW_ERROR( 1, "recv pkt size %d < required %d", rc, sizeof(trfs_pkt_t) );
goto again;
}
trfs_pkt_t *rq = (trfs_pkt_t *)buf;
SHOW_FLOW( 6, "got pkt type %d", rq->type );
if(rq->sessionId != sessionId)
{
trfs_reset_session(rq->sessionId);
if(rq->type != PKT_T_Error)
continue;
}
switch(rq->type)
{
case PKT_T_Error: recvError(rq); break;
case PKT_T_ReadReply: recvReadReply(rq); break;
case PKT_T_FindReply: recvFindReply(rq); break;
default:
SHOW_ERROR( 0, "TRFS: unknown packet type %d", rq->type);
}
}
}
int switchResp(struct text * text) {
switch((int)text->txt_type) {
case TXT_ERROR:
return recvError((struct text_error *) text);
case TXT_LIST:
return recvList((struct text_list *) text);
case TXT_WHO:
return recvWho((struct text_who *) text);
case TXT_SAY:
return recvSay((struct text_say *) text);
default:
printError("Unknown response type received\n");
return false;
}
}
void TZlibAsyncChannel::RecvRequest::recvSuccess() {
// Uncompress the buffer
try {
// Process in 64kb blocks
const uint32_t kUncompressBlock = 1 << 16;
while (true) {
uint8_t* writePtr = callbackBuffer_->getWritePtr(kUncompressBlock);
uint32_t readBytes = zlibTransport_.read(writePtr, kUncompressBlock);
if (readBytes <= 0) {
break;
} else {
callbackBuffer_->wroteBytes(readBytes);
}
}
} catch (const std::exception& ex) {
T_ERROR("zlib channel: error uncompressing data: %s", ex.what());
recvError();
return;
}
invokeCallback(callback_);
}
int TransferServer::onReceive(ConnectionIdentifier client)
{
Stream stream;
int ret;
//receive the package length at first!
stream.resize(4);
ret = client.m_socketid.recv(stream.getWriteBuffer(), (int)stream.size(), Timestamp(5,0));
//check valid header
if(ret != 4)
{
if(ret > 0)
{
m_logger.log(LogLevel::ERR, client.m_clientid,
"RCV: failed, just received(%d) bytes\n", ret);
}
return recvError(ret);
}
std::string binbuf;
m_logger.log(LogLevel::INFO, client.m_clientid,
"RCV: header :%s\n",
cacti::StringUtil::formatBinary((unsigned char*)stream.getWriteBuffer(), (int)stream.size(), binbuf));
//convert to host byte order
u32 length;
stream.get32(length);
if(length == 0)
{
m_logger.log(LogLevel::INFO, client.m_clientid, "RCV: client want close!\n");
return RECV_WANT_CLOSE;
}
stream.reset(); // reset the decode position
u32 left = length;
//package can't just have the length field.
if(left == 0 || left >= MAX_NP_SIZE)
{
m_logger.log(LogLevel::ERR, client.m_clientid,
"RCV: invalid length(%d)\n", length);
return RECV_USER_ERROR;
}
// alloc the new buffer
stream.resize(length);
//receive the left package data
ret = client.m_socketid.recv(stream.getWriteBuffer(), left, Timestamp(5,0));
if(ret != left)
{
m_logger.log(LogLevel::ERR, client.m_clientid,
"RCV: want(%d) but received(%d)\n",
left, ret);
return recvError(ret);
}
if(m_logger.isDebugEnabled())
{
binbuf = "";
m_logger.log(LogLevel::DBG, client.m_clientid, "RCV: %s\n",
cacti::StringUtil::formatBinary((unsigned char*)stream.getWriteBuffer(), (int)stream.size(), binbuf));
}
else
{
m_logger.log(LogLevel::INFO, client.m_clientid, "RCV: %d bytes\n",
stream.size());
}
if(!enqueue(client, stream))
{
m_logger.log(LogLevel::INFO, client.m_clientid, "RCV: enqueue failed\n");
return RECV_USER_ERROR;
}
return RECV_OK;
}
