void
SpamAssassinClient::ParseData(shared_ptr<ByteBuffer> pBuf)
{
if (!result_)
{
String logMessage;
logMessage.Format(_T("Parsing response from SpamAssassin. Session %d"), GetSessionID());
LOG_DEBUG(logMessage);
result_ = shared_ptr<File>(new File);
result_->Open(FileUtilities::GetTempFileName(), File::OTAppend);
spam_dsize_ = ParseFirstBuffer_(pBuf);
}
// Append output to the file
DWORD written_bytes = 0;
result_->Write(pBuf, written_bytes);
total_result_bytes_written_ += written_bytes;
if (total_result_bytes_written_ < spam_dsize_)
PostReceive();
else
FinishTesting_();
}
void Session::handle_receive( const boost::system::error_code& error, size_t bytes_transferred )
{
if( error )
{
if( error == boost::asio::error::eof )
{
std::cout << "클라이언트와 연결이 끊어졌습니다" << std::endl;
}
else
{
std::cout << "error No: " << error.value() << " error Message: " << error.message() << std::endl;
}
_SessionDesc desc;
desc.sessionType = 0;
desc.identifier = 1;
m_pServer->CloseSession( m_nSessionID );
OnDisconnect(m_nSessionID, desc);
}
else
{
_SessionDesc desc;
desc.sessionType = 0;
desc.identifier = 1;
if (false == OnReceive(m_ReceiveBuffer.data(), bytes_transferred, desc))
{
//강제로 끊게 하는 메소드는?
}
PostReceive();
}
}
void RedisNet::HandleConnect(const boost::system::error_code& error)
{
if(error)
{
cerr << "connect failed : " << error.message() << endl;
return;
}
cerr << "connected" << endl;
PostReceive();
}
void
SMTPClientConnection::ParseData(const AnsiString &Request)
//---------------------------------------------------------------------------()
// DESCRIPTION:
// Parses a server SMTP cmmand.
//---------------------------------------------------------------------------()
{
InternalParseData(Request);
if (m_bPendingDisconnect == false)
PostReceive();
}
void
POP3Connection::OnConnected()
{
String sData;
String sWelcome = Configuration::Instance()->GetPOP3Configuration()->GetWelcomeMessage();
sData += "+OK ";
if (sWelcome.IsEmpty())
sData += _T("POP3");
else
sData += sWelcome;
_SendData(sData);
PostReceive();
}
void Session::handle_receive(const boost::system::error_code& error, size_t bytes_transferred) {
if( error ) {
if( error == boost::asio::error::eof ) {
std::cout << " Disconnected " << std::endl;
} else {
std::cout << " Error no : " << error.value() << " error Message : " << error.message() << std::endl;
}
} else {
const std::string strRecvMessage = m_szReceiveBuffer;
std::cout << " Message from client : " << strRecvMessage << ", size : " << bytes_transferred << std::endl;
char szMessage[128] = {0,};
snprintf(szMessage, 128-1 , "Re:%s", strRecvMessage.c_str());
m_WriteMessage = szMessage;
boost::asio::async_write(m_Socket, boost::asio::buffer(m_WriteMessage),
boost::bind(&Session::handle_write, this,
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred));
PostReceive();
}
}
void
SpamAssassinClient::ParseData(shared_ptr<ByteBuffer> pBuf)
{
if (!m_pResult)
{
String logMessage;
logMessage.Format(_T("Parsing response from SpamAssassin. Session %d"), GetSessionID());
LOG_DEBUG(logMessage);
m_pResult = shared_ptr<File>(new File);
m_pResult->Open(FileUtilities::GetTempFileName(), File::OTAppend);
m_iSpamDSize = _ParseFirstBuffer(pBuf);
}
// Append output to the file
DWORD dwWritten = 0;
m_pResult->Write(pBuf, dwWritten);
PostReceive();
}
void RedisNet::HandleReceive(const boost::system::error_code& error, size_t bytes_transferred)
{
if(error)
{
if(error == boost::asio::error::eof)
{
cerr << "HandleReceive() Disconnected" << endl;
}
else
{
cerr << "HandleReceive() error No : " << error.value() << " Error Message : " << error.message() << endl;
}
return;
}
const string recvMessage = recvBuffer_.data();
// cerr << "HandleReceive() bytes_transferred : " << bytes_transferred << endl;
// cerr << "HandleReceive() recvMessage : " << recvMessage << ", size : " << bytes_transferred << endl;
pClient_->responseRedis(recvMessage);
// cout << "Thread ID : " << boost::this_thread::get_id() << endl;
PostReceive();
}
void
POP3Connection::ParseData(const AnsiString &Request)
//---------------------------------------------------------------------------()
// DESCRIPTION:
// Parses a client POP3 command.
//---------------------------------------------------------------------------()
{
// If we're currently processing a command, we should queue up the new command.
ParseResult result = InternalParseData(Request);
switch (result)
{
case ResultNormalResponse:
PostReceive();
break;
case ResultStartSendMessage:
break;
case ResultDisconnect:
PostDisconnect();
break;
}
}
void
SMTPClientConnection::OnConnected()
{
PostReceive();
}
BOOL CommonCmdHandler (
IN void *pvCmdBuf, // Address of buffer contaiing command packet
IN size_t tCmdSize, // Size of command packet
OUT void *pvRspBuf, // Address of buffer for response packet
IN size_t tRspSize // Expected size of response packet
)
{
BOOL bSucceeded = FALSE; // Success indicator
DWORD dwCount; // Count returned by WriteFile()/ReadFile()
DWORD dwStatus; // Buffer for status codes
int iRetries; // Retry counter
// Obtain (thread) exclusive access to resources
switch( WaitForSingleObject( hMutex, INFINITE ) )
{
case WAIT_ABANDONED:
case WAIT_OBJECT_0:
break;
default:
return( FALSE );
}
// Attach to HECI driver if we aren't already
if( !bAttached && !AttachDriver() )
{
// Couldn't attach the driver...
dwStatus = GetLastError();
}
else
{
// Attached; now have info to verify max command/response size...
if( (tCmdSize > stProperties.minRxBufferSize) || (tRspSize > stProperties.minRxBufferSize) )
dwStatus = ERROR_BAD_LENGTH;
// Length ok, attempt communication...
else
{
// Support retries during communication...
for( iRetries = 0; iRetries < RETRY_COUNT; iRetries++ )
{
bReceivePosted = FALSE;
// Post Receive Buffer if a response expected
if( (tRspSize == 0) || PostReceive( pvBuffer, stProperties.minRxBufferSize ) )
{
// Send Command Packet
if( DoSend( pvCmdBuf, tCmdSize ) )
{
// If no response is desired, we're done!
if( tRspSize == 0 )
{
bSucceeded = TRUE;
break;
}
// Receive and process Response Packet
dwCount = CompleteReceive( TRUE );
if( dwCount )
{
// Have a response; verify it
if( (dwCount != tRspSize) && (CheckRspSuccess(pvBuffer)) )
{
// Data received is larger/smaller than expected
dwStatus = ERROR_BAD_LENGTH;
}
else
{
// Data received is right length (or QST rejected command)
// Place info available into caller's buffer
memcpy( pvRspBuf, pvBuffer, __min(dwCount, tRspSize) );
bSucceeded = TRUE;
}
// We're done!
break;
}
}
// Remember ccode from first failed operation...
if( iRetries == 0 )
dwStatus = GetLastError();
// Won't need the buffer we posted...
if( tRspSize != 0 )
CancelReceive();
}
// A retry is necessary; recreate attachment to driver in case lost due to PM transition, etc.
DetachDriver();
if( !AttachDriver() )
break; // Can't reattach, time to give up
if( !AsyncDelay( RETRY_DELAY ) ) // Delay retry to give driver a break
break;
}
}
}
ReleaseMutex( hMutex );
if( !bSucceeded )
SetLastError( dwStatus ); // Indicate why we're failing
return (bSucceeded);
}
