int main(int argc, char **argv)
{
CPassiveSocket socket;
CActiveSocket *pClient = NULL;
//--------------------------------------------------------------------------
// Initialize our socket object
//--------------------------------------------------------------------------
socket.Initialize();
socket.Listen((const uint8 *)"127.0.0.1", 6789);
while (true)
{
if ((pClient = socket.Accept()) != NULL)
{
//------------------------------------------------------------------
// Receive request from the client.
//------------------------------------------------------------------
if (pClient->Receive(MAX_PACKET))
{
// ERROR HERE # 7
//--------------------------------------------------------------
// Send response to client and close connection to the client.
//--------------------------------------------------------------
pClient->Send((const uint8 *)pClient->GetData(),
pClient->GetBytesReceived());
pClient->Close();
}
delete pClient;
}
}
//--------------------------------------------------------------------------
// Receive request from the client.
//--------------------------------------------------------------------------
socket.Close();
return 1;
}
static void accept_clients(void * client_pool_pointer) {
client_pool * p = reinterpret_cast<client_pool *>(client_pool_pointer);
CPassiveSocket socket;
socket.Initialize();
if (socket.Listen((const uint8 *)"0.0.0.0", 8008)) {
std::cout << "Listening on a socket" << std::endl;
} else {
std::cout << "Not listening: " << socket.GetSocketError() << std::endl;
std::cout << translate_socket_error(socket.GetSocketError()) << std::endl;
}
while (true) {
CActiveSocket * client = socket.Accept();
if (client != 0) {
lock l(*p);
p->clients.push_back(client);
}
}
}
int main(int argc, char *argv[])
{
b3CommandLineArgs parseArgs(argc,argv);
b3Clock clock;
double timeOutInSeconds = 10;
DummyGUIHelper guiHelper;
MyCommandProcessor* sm = new MyCommandProcessor;
sm->setGuiHelper(&guiHelper);
int port = 6667;
parseArgs.GetCmdLineArgument("port",port);
gVerboseNetworkMessagesServer = parseArgs.CheckCmdLineFlag("verbose");
#ifndef NO_SHARED_MEMORY
int key = 0;
if (parseArgs.GetCmdLineArgument("sharedMemoryKey",key))
{
sm->setSharedMemoryKey(key);
}
#endif//NO_SHARED_MEMORY
bool isPhysicsClientConnected = sm->connect();
bool exitRequested = false;
if (isPhysicsClientConnected)
{
printf("Starting TCP server using port %d\n", port);
CPassiveSocket socket;
CActiveSocket *pClient = NULL;
//--------------------------------------------------------------------------
// Initialize our socket object
//--------------------------------------------------------------------------
socket.Initialize();
socket.Listen("localhost", port);
//socket.SetBlocking();
int curNumErr = 0;
while (!exitRequested)
{
b3Clock::usleep(0);
if ((pClient = socket.Accept()) != NULL)
{
b3AlignedObjectArray<char> bytesReceived;
int clientPort = socket.GetClientPort();
printf("connected from %s:%d\n", socket.GetClientAddr(),clientPort);
if (pClient->Receive(4))
{
int clientKey = *(int*)pClient->GetData();
if (clientKey==SHARED_MEMORY_MAGIC_NUMBER)
{
printf("Client version OK %d\n", clientKey);
} else
{
printf("Server version (%d) mismatches Client Version (%d)\n", SHARED_MEMORY_MAGIC_NUMBER,clientKey);
continue;
}
}
//----------------------------------------------------------------------
// Receive request from the client.
//----------------------------------------------------------------------
while (1)
{
//printf("try receive\n");
bool receivedData = false;
int maxLen = 4 + sizeof(SharedMemoryStatus)+SHARED_MEMORY_MAX_STREAM_CHUNK_SIZE;
if (pClient->Receive(maxLen))
{
//heuristic to detect disconnected clients
CSimpleSocket::CSocketError err = pClient->GetSocketError();
if (err != CSimpleSocket::SocketSuccess || !pClient->IsSocketValid())
{
b3Clock::usleep(100);
curNumErr++;
if (curNumErr>100)
{
printf("TCP Connection error = %d, curNumErr = %d\n", (int)err, curNumErr);
break;
}
}
curNumErr = 0;
char* msg2 = (char*) pClient->GetData();
int numBytesRec2 = pClient->GetBytesReceived();
int curSize = bytesReceived.size();
bytesReceived.resize(bytesReceived.size()+numBytesRec2);
for (int i=0;i<numBytesRec2;i++)
{
bytesReceived[curSize+i] = msg2[i];
}
if (bytesReceived.size() >= 4)
{
int numBytesRec = bytesReceived.size();
if (numBytesRec>=10)
{
if (strncmp(&bytesReceived[0],"disconnect",10)==0)
{
printf("Disconnect request received\n");
bytesReceived.clear();
break;
}
if (strncmp(&bytesReceived[0],"terminateserver",10)==0)
{
printf("Terminate server request received\n");
exitRequested = true;
bytesReceived.clear();
break;
}
}
if (gVerboseNetworkMessagesServer)
{
printf("received message length [%d]\n",numBytesRec);
}
receivedData = true;
SharedMemoryCommand cmd;
SharedMemoryCommand* cmdPtr = 0;
int type = *(int*)&bytesReceived[0];
//performance test
if (numBytesRec == sizeof(int))
{
cmdPtr = &cmd;
cmd.m_type = *(int*)&bytesReceived[0];
}
else
{
if (numBytesRec == sizeof(SharedMemoryCommand))
{
cmdPtr = (SharedMemoryCommand*)&bytesReceived[0];
}
else
{
if (numBytesRec==36)
{
cmdPtr = &cmd;
memcpy(&cmd, &bytesReceived[0], numBytesRec);
}
}
}
if (cmdPtr)
{
SharedMemoryStatus serverStatus;
b3AlignedObjectArray<char> buffer;
buffer.resize(SHARED_MEMORY_MAX_STREAM_CHUNK_SIZE);
bool hasStatus = sm->processCommand(*cmdPtr,serverStatus, &buffer[0], buffer.size());
double startTimeSeconds = clock.getTimeInSeconds();
double curTimeSeconds = clock.getTimeInSeconds();
while ((!hasStatus) && ((curTimeSeconds - startTimeSeconds) <timeOutInSeconds))
{
hasStatus = sm->receiveStatus(serverStatus, &buffer[0], buffer.size());
curTimeSeconds = clock.getTimeInSeconds();
}
if (gVerboseNetworkMessagesServer)
{
//printf("buffer.size = %d\n", buffer.size());
printf("serverStatus.m_numDataStreamBytes = %d\n", serverStatus.m_numDataStreamBytes);
}
if (hasStatus)
{
b3AlignedObjectArray<unsigned char> packetData;
unsigned char* statBytes = (unsigned char*)&serverStatus;
if (cmdPtr->m_type == CMD_STEP_FORWARD_SIMULATION)
{
packetData.resize(4 + sizeof(int));
int sz = packetData.size();
int curPos = 0;
MySerializeInt(sz, &packetData[curPos]);
curPos += 4;
for (int i = 0; i < sizeof(int); i++)
{
packetData[i + curPos] = statBytes[i];
}
curPos += sizeof(int);
pClient->Send( &packetData[0], packetData.size() );
}
else
{
if (cmdPtr->m_type == CMD_REQUEST_VR_EVENTS_DATA)
{
int headerSize = 16+5 * sizeof(int) + sizeof(smUint64_t) + sizeof(char*) + sizeof(b3VRControllerEvent)*serverStatus.m_sendVREvents.m_numVRControllerEvents;
packetData.resize(4 + headerSize);
int sz = packetData.size();
int curPos = 0;
MySerializeInt(sz, &packetData[curPos]);
curPos += 4;
for (int i = 0; i < headerSize; i++)
{
packetData[i + curPos] = statBytes[i];
}
curPos += headerSize;
pClient->Send(&packetData[0], packetData.size());
}
else
{
//create packetData with [int packetSizeInBytes, status, streamBytes)
packetData.resize(4 + sizeof(SharedMemoryStatus) + serverStatus.m_numDataStreamBytes);
int sz = packetData.size();
int curPos = 0;
if (gVerboseNetworkMessagesServer)
{
//printf("buffer.size = %d\n", buffer.size());
printf("serverStatus packed size = %d\n", sz);
}
MySerializeInt(sz, &packetData[curPos]);
curPos += 4;
for (int i = 0; i < sizeof(SharedMemoryStatus); i++)
{
packetData[i + curPos] = statBytes[i];
}
curPos += sizeof(SharedMemoryStatus);
for (int i = 0; i < serverStatus.m_numDataStreamBytes; i++)
{
packetData[i + curPos] = buffer[i];
}
pClient->Send(&packetData[0], packetData.size());
}
}
}
bytesReceived.clear();
}
else
{
//likely an incomplete packet, let's append more bytes
//printf("received packet with unknown contents\n");
}
}
}
if (!receivedData)
{
//printf("Didn't receive data.\n");
}
}
printf("Disconnecting client.\n");
pClient->Close();
delete pClient;
}
}
socket.Close();
socket.Shutdown(CSimpleSocket::Both);
} else
{
printf("Error: cannot connect to shared memory physics server.");
}
delete sm;
return 0;
}
