int main(int argc, char* argv[]){
if(argc < 2){
printf("need to provide a conf file!\n");
exit(1);
}
setParameters(argv[1]);
struct sockaddr_in fsin;
int hSock, rc;
hSock = hostsock(portnum, 32);
unsigned int fsize = sizeof(fsin);
while(1){
int incoming;
incoming = accept(hSock, (struct sockaddr*)&fsin, &fsize);
struct targs* newargs = malloc(sizeof(struct targs));
newargs -> newSock = incoming;
pthread_t newConnection;
//spawn a new thread on receipt of a new connection
rc = pthread_create(&newConnection, NULL, (void*)handleRequest, (void*)(newargs));
if(rc < 0){
printf("pthread failed!\n");
sendServerError(incoming);
close(incoming);
free(newargs);
}
}
}
void AsioSessionState::onAccept(
const boost::system::error_code& error)
{
RCF2_TRACE("")(this);
if (mTransport.mStopFlag)
{
return;
}
if (!error)
{
// save the remote address in the SessionState object
bool clientAddrAllowed = implOnAccept();
mState = WritingData;
// create a new SessionState, and do an accept on that
mTransport.createSessionState()->invokeAsyncAccept();
// set current RCF session
SetCurrentSessionGuard guard(mSessionPtr);
if (clientAddrAllowed)
{
// Check the connection limit.
bool allowConnect = true;
std::size_t connectionLimit = mTransport.getConnectionLimit();
if (connectionLimit)
{
Lock lock(mTransport.mSessionsMutex);
RCF_ASSERT(
mTransport.mSessions.size() <= 1 + 1 + connectionLimit);
if (mTransport.mSessions.size() == 1 + 1 + connectionLimit)
{
allowConnect = false;
}
}
if (allowConnect)
{
// start things rolling by faking a completed write operation
onReadWrite(0, boost::system::error_code());
}
else
{
sendServerError(RcfError_ConnectionLimitExceeded);
}
}
}
else if (
error == boost::asio::error::connection_aborted ||
error == boost::asio::error::operation_aborted)
{
invokeAsyncAccept();
}
}
void AsioSessionState::doRegularFraming(size_t bytesTransferred)
{
RCF_ASSERT_LTEQ(bytesTransferred , mReadBufferRemaining);
mReadBufferRemaining -= bytesTransferred;
if (mReadBufferRemaining > 0)
{
beginRead();
}
else if (mReadBufferRemaining == 0 && mIssueZeroByteRead)
{
if (!mAppReadBufferPtr || !mAppReadBufferPtr.unique())
{
mAppReadBufferPtr = getObjectPool().getReallocBufferPtr();
}
mAppReadBufferPtr->resize(4);
mReadBufferRemaining = 4;
mIssueZeroByteRead = false;
beginRead();
}
else
{
RCF_ASSERT_EQ(mReadBufferRemaining , 0);
if (mState == ReadingDataCount)
{
ReallocBuffer & readBuffer = *mAppReadBufferPtr;
RCF_ASSERT_EQ(readBuffer.size() , 4);
unsigned int packetLength = 0;
memcpy(&packetLength, &readBuffer[0], 4);
networkToMachineOrder(&packetLength, 4, 1);
if ( mTransport.getMaxMessageLength()
&& packetLength > mTransport.getMaxMessageLength())
{
sendServerError(RcfError_ServerMessageLength);
}
else
{
readBuffer.resize(packetLength);
mReadBufferRemaining = packetLength;
mState = ReadingData;
beginRead();
}
}
else if (mState == ReadingData)
{
mState = Ready;
mTransport.getSessionManager().onReadCompleted(
getSessionPtr());
}
}
}
void AsioSessionState::doCustomFraming(size_t bytesTransferred)
{
RCF_ASSERT_LTEQ(bytesTransferred , mReadBufferRemaining);
mReadBufferRemaining -= bytesTransferred;
if (mReadBufferRemaining > 0)
{
beginRead();
}
else if (mReadBufferRemaining == 0 && mIssueZeroByteRead)
{
if (!mAppReadBufferPtr || !mAppReadBufferPtr.unique())
{
mAppReadBufferPtr = getObjectPool().getReallocBufferPtr();
}
mAppReadBufferPtr->resize(4);
mReadBufferRemaining = 4;
mIssueZeroByteRead = false;
beginRead();
}
else
{
RCF_ASSERT_EQ(mReadBufferRemaining , 0);
if (mState == ReadingDataCount)
{
ReallocBuffer & readBuffer = *mAppReadBufferPtr;
RCF_ASSERT_EQ(readBuffer.size() , 4);
std::size_t messageLength = mTransportFilters[0]->getFrameSize();
if ( mTransport.getMaxMessageLength()
&& messageLength > mTransport.getMaxMessageLength())
{
sendServerError(RcfError_ServerMessageLength);
}
else
{
RCF_ASSERT( messageLength > 4 );
readBuffer.resize(messageLength);
mReadBufferRemaining = messageLength - 4;
mState = ReadingData;
beginRead();
}
}
else if (mState == ReadingData)
{
mState = Ready;
mTransport.getSessionManager().onReadCompleted(
getSessionPtr());
}
}
}
void AsioSessionState::onAcceptCompleted(
const AsioErrorCode & error)
{
RCF_LOG_4()(error.value())
<< "AsioSessionState - onAccept().";
if (mTransport.mStopFlag)
{
RCF_LOG_4()(error.value())
<< "AsioSessionState - onAccept(). Returning early, stop flag is set.";
return;
}
//if (
// error == ASIO_NS::error::connection_aborted ||
// error == ASIO_NS::error::operation_aborted)
//{
// beginAccept();
// return;
//}
// create a new SessionState, and do an accept on that
mTransport.createSessionState()->beginAccept();
if (!error)
{
// save the remote address in the SessionState object
bool clientAddrAllowed = implOnAccept();
mState = WritingData;
// set current RCF session
CurrentRcfSessionSentry guard(*mSessionPtr);
mSessionPtr->touch();
if (clientAddrAllowed)
{
// Check the connection limit.
bool allowConnect = true;
std::size_t connectionLimit = mTransport.getConnectionLimit();
if (connectionLimit)
{
Lock lock(mTransport.mSessionsMutex);
RCF_ASSERT_LTEQ(
mTransport.mSessions.size() , 1+1+connectionLimit);
if (mTransport.mSessions.size() == 1+1+connectionLimit)
{
allowConnect = false;
}
}
if (allowConnect)
{
time_t now = 0;
now = time(NULL);
mSessionPtr->setConnectedAtTime(now);
// start things rolling by faking a completed write operation
onAppReadWriteCompleted(0);
}
else
{
sendServerError(RcfError_ConnectionLimitExceeded);
}
}
}
}
void AsioSessionState::onReadWrite(
size_t bytesTransferred,
const boost::system::error_code& error)
{
RCF_ASSERT(!error);
RCF_ASSERT(!mReflecting);
{
switch(mState)
{
case ReadingDataCount:
case ReadingData:
RCF_ASSERT(
bytesTransferred <= mReadBufferRemaining)
(bytesTransferred)(mReadBufferRemaining);
mReadBufferRemaining -= bytesTransferred;
if (mReadBufferRemaining > 0)
{
invokeAsyncRead();
}
else
{
RCF_ASSERT(mReadBufferRemaining == 0)(mReadBufferRemaining);
if (mState == ReadingDataCount)
{
std::vector<char> &readBuffer = getReadBuffer();
RCF_ASSERT(readBuffer.size() == 4)(readBuffer.size());
unsigned int packetLength = 0;
memcpy(&packetLength, &readBuffer[0], 4);
networkToMachineOrder(&packetLength, 4, 1);
if (packetLength <= mTransport.getMaxMessageLength())
{
readBuffer.resize(packetLength);
mReadBufferRemaining = packetLength;
mState = ReadingData;
invokeAsyncRead();
}
else
{
sendServerError(RcfError_ServerMessageLength);
}
}
else if (mState == ReadingData)
{
mState = Ready;
mTransport.getSessionManager().onReadCompleted(
getSessionPtr());
if (mTransport.mInterrupt)
{
mTransport.mInterrupt = false;
mTransport.mDemuxerPtr->stop();
}
}
}
break;
case WritingData:
RCF_ASSERT(
bytesTransferred <= mWriteBufferRemaining)
(bytesTransferred)(mWriteBufferRemaining);
mWriteBufferRemaining -= bytesTransferred;
if (mWriteBufferRemaining > 0)
{
invokeAsyncWrite();
}
else
{
if (mCloseAfterWrite)
{
int fd = implGetNative();
const int BufferSize = 8*1024;
char buffer[BufferSize];
while (recv(fd, buffer, BufferSize, 0) > 0);
}
else
{
mState = Ready;
mSlicedWriteByteBuffers.resize(0);
mWriteByteBuffers.resize(0);
mTransport.getSessionManager().onWriteCompleted(
getSessionPtr());
if (mTransport.mInterrupt)
{
mTransport.mInterrupt = false;
mTransport.mDemuxerPtr->stop();
}
}
}
break;
default:
RCF_ASSERT(0);
}
}
}
