bool readLinesFromClientTest(const int linesize=TcpSocket::DEFAULT_MAX_MSG){
cout << "Starting readLinesFromClientTest(" << linesize << ") ...\n";
string message("Passaro verde abandona ninho. \nEscuto!\n");
pid_t child;
// client code
if ((child=fork())==0){
try {
TcpSocket toServer;
cout << " Forked child waiting a bit\n";
sleep(1);
cout << " Forked child connecting to server\n";
toServer.connect("127.0.0.1",LOCALPORT);
cout << " Forked child connected: " << toServer << endl;
cout << " Forked child sending to server\n";
toServer.writeline(message);
cout << " Forked child closing connection to server\n";
toServer.close();
cout << " Forked child exiting\n";
exit(0);
} catch (std::exception& e) {
cout << " Forked child exception: " << e.what() << endl;
exit(-1);
}
return false; // for clarity
}
// server code
TcpSocket* connectedSocket;
try {
TcpSocket serverSocket;
connectedSocket = bindListenAccept(LOCALPORT, serverSocket);
std::string clientmessage;
cout << " Reading one (at most " << linesize << " chars long) line from client\n";
// Read a line
connectedSocket->setMaxReceive(linesize);
while ((*connectedSocket) >> clientmessage);
if (clientmessage.empty())
throw std::runtime_error("clinet message is empty");
cout << " Read: \"" << clientmessage << "\"\n";
if (!(clientmessage.compare(message) == 0)){
throw std::runtime_error("Messages dont match");
}
checkChild(child);
serverSocket.close();
connectedSocket->close();
cout << "Done!\n";
delete connectedSocket;
return true;
} catch (std::exception& e) {
cout << " Server exception: " << e.what() << endl;
cout << "Failed!\n";
checkChild(child, true);
delete connectedSocket;
return false;
}
}
bool sendReceiveObjectTest(){
cout << "sendReceiveObjectTest() ...\n";
Object tosend('c', 34, true, "cinco");
pid_t child;
// client code
if ((child=fork())==0){
try {
TcpSocket toServer;
cout << " Forked child waiting a bit\n";
sleep(1);
cout << " Forked child connecting to server\n";
toServer.connect("127.0.0.1",LOCALPORT);
cout << " Forked child connected: " << toServer << endl;
cout << " Forked child sending to server\n";
toServer.write(reinterpret_cast<char *>(&tosend), sizeof(Object));
cout << " Forked child closing connection to server\n";
toServer.close();
cout << " Forked child exiting\n";
exit(0);
} catch (std::exception& e) {
cout << " Forked child exception: " << e.what() << endl;
exit(-1);
}
return false; // for clarity
}
// server code
TcpSocket* connectedSocket;
try {
TcpSocket serverSocket;
connectedSocket = bindListenAccept(LOCALPORT, serverSocket);
std::string clientmessage;
cout << " Reading one object from client\n";
// Read the object
Object received;
int len = connectedSocket->read(reinterpret_cast<char *>(&received), sizeof(Object));
cout << " Read: " << len << " bytes from " << *connectedSocket << endl;
if (!(tosend.compare(received) == 0))
throw std::runtime_error("objects dont match");
cout << " Server read " << received << endl;
checkChild(child);
serverSocket.close();
connectedSocket->close();
cout << "Done!\n";
delete connectedSocket;
return true;
} catch (std::exception& e) {
cout << " Server exception: " << e.what() << endl;
cout << "Failed!\n";
checkChild(child, true);
delete connectedSocket;
return false;
}
}
void* dabInputSlipThread(void* args)
{
dabInputSlipData* data = (dabInputSlipData*)args;
TcpSocket* client;
while ((client = data->server->accept()) != NULL) {
int size = 0;
etiLog.log(info, "SLIP server got a new client.\n");
#ifdef _WIN32
WaitForSingleObject(data->semWrite, INFINITE);
WaitForSingleObject(data->semQueue, INFINITE);
#else
sem_wait(&data->semWrite);
sem_wait(&data->semQueue);
#endif
UdpPacket* packet = data->packets[data->nbPackets];
#ifdef _WIN32
ReleaseSemaphore(data->semQueue, 1, NULL);
#else
sem_post(&data->semQueue);
#endif
while ((size = client->read(packet->getData(), packet->getSize()))
> 0) {
packet->setLength(size);
#ifdef _WIN32
WaitForSingleObject(data->semQueue, INFINITE);
#else
sem_wait(&data->semQueue);
#endif
data->nbPackets++;
#ifdef _WIN32
ReleaseSemaphore(data->semQueue, 1, NULL);
#else
sem_post(&data->semQueue);
#endif
#ifdef _WIN32
WaitForSingleObject(data->semWrite, INFINITE);
WaitForSingleObject(data->semQueue, INFINITE);
#else
sem_wait(&data->semWrite);
sem_wait(&data->semQueue);
#endif
packet = data->packets[data->nbPackets];
#ifdef _WIN32
ReleaseSemaphore(data->semQueue, 1, NULL);
#else
sem_post(&data->semQueue);
#endif
}
etiLog.log(info, "SLIP server client deconnected.\n");
client->close();
}
etiLog.log(error, "SLIP thread can't accept new client (%s)\n",
inetErrDesc, inetErrMsg);
return NULL;
}
bool simpleAcceptConnectTest(){
cout << "Starting simpleAcceptConnectTest() ...\n";
pid_t child;
// client code
if ((child=fork())==0){
try {
TcpSocket toServer;
cout << " Forked child waiting a bit\n";
sleep(1);
cout << " Forked child connecting to server\n";
toServer.connect("127.0.0.1",LOCALPORT);
cout << " Forked child connected: " << toServer << endl;
cout << " Forked child closing connection to server\n";
toServer.close();
cout << " Forked child exiting\n";
exit(0);
} catch (TcpSocket::SocketException& e) {
cout << " Forked child exception: " << e.what() << endl;
exit(-1);
}
return false; // for clarity
}
// server code
TcpSocket* toClient;
try {
TcpSocket serverSocket;
toClient = bindListenAccept(LOCALPORT, serverSocket);
cout << " Server closing connection to client\n";
toClient->close();
cout << " Server closing listening socket\n";
serverSocket.close();
checkChild(child);
cout << "Done!\n";
delete toClient;
return true;
} catch (std::exception& e) {
cout << " Server exception: " << e.what() << endl;
cout << "Failed!\n";
checkChild(child, true);
delete toClient;
return false;
}
}
int main(void) {
TcpSocket servSocket;
servSocket.create();
servSocket.connect("127.0.0.1", 9999);
Message msg;
msg.add("type", "login");
msg.add("user", "root");
msg.add("pwd", "root");
servSocket << msg;
servSocket.close();
return 0;
}
bool
HttpServer::send_response(TcpSocket &cl_sock, Yb::ILogger &logger,
int code, const string &desc, const string &body,
const string &cont_type)
{
try {
ostringstream out;
out << "HTTP/1.0 " << code << " " << desc
<< "\nContent-Type: " << cont_type
<< "\nContent-Length: " << body.size()
<< "\n\n" << body;
logger.debug("HTTP response:\n" + out.str());
cl_sock.write(out.str());
cl_sock.close(true);
return true;
}
catch (const std::exception &ex) {
logger.error(string("exception: ") + ex.what());
return false;
}
}
int main()
{
TcpServer server;
if (server.listen(2000) != AbstractSocket::Done)
{
perror("Error :");
return -1;
}
TcpSocket* s = server.accept();
if (s == NULL)
{
cout << "Error: cannot accept conection" << endl;
return -1;
}
cout << "Connected client" << endl;
int i = 4;
i++;
cout << "Remote host : " << s->getRemotePort() << endl;
cout << s->getLocalPort() << endl;
cout << server.getRemoteAddress().toString() << endl;
cout << s->getRemoteAddress().toString() << endl;
s->sendInt32(10);
sleep(2);
s->sendString("hello");
s->sendCharArray("world", 5);
Frame f;
f << "This is a frame " << 666 << '\n';
if (s->sendFrame(f) != AbstractSocket::Done)
perror("error on send frame");
delete s;
server.close();
s->close();
return 1;
}
Socket::Status TcpListener::accept(TcpSocket& socket)
{
// Make sure that we're listening
if (getHandle() == priv::SocketImpl::invalidSocket())
{
err() << "Failed to accept a new connection, the socket is not listening" << std::endl;
return Error;
}
// Accept a new connection
sockaddr_in address;
priv::SocketImpl::AddrLength length = sizeof(address);
SocketHandle remote = ::accept(getHandle(), reinterpret_cast<sockaddr*>(&address), &length);
// Check for errors
if (remote == priv::SocketImpl::invalidSocket())
return priv::SocketImpl::getErrorStatus();
// Initialize the new connected socket
socket.close();
socket.create(remote);
return Done;
}
ServiceManager::~ServiceManager()
{
uint32 maxTcpNum = m_tcpSktClrNum*m_perClrTcpSktNum;
for (uint32 i=0; (i<maxTcpNum && m_usingTcp); ++i)
{
TcpSocket* tcpSkt = (TcpSocket*)sTcpSktFList.get()->get(i);
if (tcpSkt)
{
tcpSkt->close();
tcpSkt->clean();
}
}
HashMapShrPtr hm = sSSLSktFList.getFls();
if (hm)
{
uint32 size = hm->arraySize();
for (uint32 i=0; i<size; ++i)
{
hm->lockWrite((ContextId)i, (ContextId)i);
std::map<ContextId, IFreeListShrPtr>& hmMap = hm->map(i);
for (std::map<ContextId, IFreeListShrPtr>::iterator itr=hmMap.begin(); itr!=hmMap.end(); ++itr)
{
uint32 maxSSLSktNum = itr->second->getClr() * itr->second->getPer();
for (uint32 j=0; (j<maxSSLSktNum && m_usingSSL); ++j)
{
SSLSocket* sslSkt = (SSLSocket*)itr->second->get(j);
if (sslSkt)
{
sslSkt->socket()->lowest_layer().close();
sslSkt->clean();
}
}
}
hm->unlockWrite((ContextId)i, (ContextId)i);
}
}
hm = HashMapShrPtr();
uint32 maxUdpSubNum = m_udpSubSktClrNum*m_perClrUdpSubSktNum;
for (uint32 i=0; (i<maxUdpSubNum && m_usingUdp); ++i)
{
UdpSubSocket* udpSubSkt = (UdpSubSocket*)sUdpSubSktFList.get()->get(i);
if (udpSubSkt)
{
udpSubSkt->close();
udpSubSkt->clean();
}
}
uint32 maxUdpNum = m_udpSktClrNum*m_perClrUdpSktNum;
for (uint32 i=0; (i<maxUdpNum && m_usingUdp); ++i)
{
UdpSocket* udpSkt = (UdpSocket*)sUdpSktFList.get()->get(i);
if (udpSkt)
{
udpSkt->socket()->close();
udpSkt->clean();
}
}
m_contexts.clear();
for (uint32 i=0; i<m_tcpAcptrSvcs.size(); ++i)
{
if (m_tcpAcptrSvcs[i])
delete m_tcpAcptrSvcs[i];
}
for (uint32 i=0; i<m_sslAcptrSvcs.size(); ++i)
{
if (m_sslAcptrSvcs[i])
delete m_sslAcptrSvcs[i];
}
for (uint32 i=0; i<m_udpAcptrSvcs.size(); ++i)
{
if (m_udpAcptrSvcs[i])
delete m_udpAcptrSvcs[i];
}
for (uint32 i=0; i<m_tcpSvcs.size(); ++i)
{
if (m_tcpSvcs[i])
delete m_tcpSvcs[i];
}
for (uint32 i=0; i<m_sslSvcs.size(); ++i)
{
if (m_sslSvcs[i])
delete m_sslSvcs[i];
}
for (uint32 i=0; i<m_udpSvcs.size(); ++i)
{
if (m_udpSvcs[i])
delete m_udpSvcs[i];
}
}
int main(int argc, char* argv[]) {
startRobogen();
interrupted = false;
if (argc < 2) {
std::cerr << "Please, provide server port." << std::endl;
exitRobogen(EXIT_FAILURE);
}
// Parameters: <PORT>
int port = std::atoi(argv[1]);
if (!port) {
std::cerr << "The first argument must be a server port." << std::endl;
exitRobogen(EXIT_FAILURE);
}
bool visualize = false;
bool startPaused = false;
for (int currentArg=2; currentArg<argc; currentArg++) {
if (std::string(argv[currentArg]).compare("--visualization") == 0) {
visualize = true;
} else if (std::string(argv[currentArg]).compare("--pause") == 0) {
startPaused = true;
}
}
if (startPaused && !visualize) {
std::cerr << "Cannot start paused without visualization enabled." <<
std::endl;
exitRobogen(EXIT_FAILURE);
}
TcpSocket socket;
bool rc = socket.create(port);
if (!rc) {
std::cerr << "Cannot listen for incoming connections on port " << port
<< std::endl;
exitRobogen(EXIT_FAILURE);
}
boost::random::mt19937 rng;
rng.seed(port);
#ifdef QT5_ENABLED
QCoreApplication a(argc, argv);
#endif
while (!interrupted) {
// Wait for client to connect
std::cout << "Waiting for clients..." << std::endl;
rc = socket.accept();
if (rc) {
std::cout << "Client connected..." << std::endl;
while (true) {
try {
// ---------------------------------------
// Decode solution
// ---------------------------------------
ProtobufPacket<robogenMessage::EvaluationRequest> packet;
// 1) Read packet header
std::vector<unsigned char> headerBuffer;
socket.read(headerBuffer,
ProtobufPacket<robogenMessage::EvaluationRequest>::HEADER_SIZE);
unsigned int packetSize = packet.decodeHeader(headerBuffer);
// 2) Read packet size
std::vector<unsigned char> payloadBuffer;
socket.read(payloadBuffer, packetSize);
packet.decodePayload(payloadBuffer);
// ---------------------------------------
// Decode configuration file
// ---------------------------------------
boost::shared_ptr<RobogenConfig> configuration =
ConfigurationReader::parseRobogenMessage(
packet.getMessage()->configuration());
if (configuration == NULL) {
std::cerr
<< "Problems parsing the configuration file. Quit."
<< std::endl;
exitRobogen(EXIT_FAILURE);
}
// ---------------------------------------
// Setup environment
// ---------------------------------------
boost::shared_ptr<Scenario> scenario =
ScenarioFactory::createScenario(configuration);
if (scenario == NULL) {
exitRobogen(EXIT_FAILURE);
}
std::cout
<< "-----------------------------------------------"
<< std::endl;
// ---------------------------------------
// Run simulations
// ---------------------------------------
Viewer *viewer = NULL;
if(visualize) {
viewer = new Viewer(startPaused);
}
unsigned int simulationResult = runSimulations(scenario,
configuration, packet.getMessage()->robot(),
viewer, rng);
if(viewer != NULL) {
delete viewer;
}
if (simulationResult == SIMULATION_FAILURE) {
exitRobogen(EXIT_FAILURE);
}
// ---------------------------------------
// Compute fitness
// ---------------------------------------
double fitness;
if (simulationResult == CONSTRAINT_VIOLATED) {
fitness = MIN_FITNESS;
} else {
fitness = scenario->getFitness();
}
std::cout << "Fitness for the current solution: " << fitness
<< std::endl << std::endl;
// ---------------------------------------
// Send reply to EA
// ---------------------------------------
boost::shared_ptr<robogenMessage::EvaluationResult> evalResultPacket(
new robogenMessage::EvaluationResult());
evalResultPacket->set_fitness(fitness);
evalResultPacket->set_id(packet.getMessage()->robot().id());
ProtobufPacket<robogenMessage::EvaluationResult> evalResult;
evalResult.setMessage(evalResultPacket);
std::vector<unsigned char> sendBuffer;
evalResult.forge(sendBuffer);
socket.write(sendBuffer);
} catch (boost::system::system_error& e) {
socket.close();
exitRobogen(EXIT_FAILURE);
}
}
} else {
std::cerr << "Cannot connect to client. Exiting." << std::endl;
socket.close();
exitRobogen(EXIT_FAILURE);
}
}
exitRobogen(EXIT_SUCCESS);
}
void Worker::readClient()
{
//if (disabled)
// return;
// This slot is called when the client sent data to the server. The
// server looks if it was a get request and sends a very simple HTML
// document back.
TcpSocket* socket = static_cast<TcpSocket*>(sender());
if(socket->bytesAvailable())
{
if ( socket->isNewSocket())
{
QByteArray incomingContent=socket->readAll();
http_parser_settings settings;
settings. on_message_begin=onMessageBegin;
settings. on_url=onUrl;
settings. on_header_field=onHeaderField;
settings. on_header_value=onHeaderValue;
settings. on_headers_complete=onHeadersComplete;
settings. on_body=onBody;
settings. on_message_complete=onMessageComplete;
http_parser_init(&m_parser,HTTP_REQUEST);
m_parser.data = socket;
size_t nparsed = http_parser_execute(&m_parser,&settings,incomingContent.constData(),incomingContent.count());
if(m_parser.upgrade)
{
qDebug()<<"upgrade";
}
else if(nparsed != static_cast<size_t>(incomingContent.count()))
{
qDebug()<<"nparsed:"<<nparsed<<"buffer size:"<<incomingContent.count();
}
else
{
//qDebug()<<"parsing seems to be succeed!";
}
socket->setRawHeader(incomingContent);
bool isBodySizeOK=false;
unsigned int bodySize = 0;
QSharedPointer<QString> contentLength = socket->getHeader().getHeaderInfo("Content-Length");
if (!contentLength.isNull())
{
bodySize = contentLength->toUInt(&isBodySizeOK);
if(isBodySizeOK==false)
{
bodySize=0;
}
}
socket->setTotalBytes(bodySize);
socket->notNew();
}
else
{
qDebug()<<"socket size:"<<socket->getTotalBytes()<<"current Size:"<<socket->getBytesHaveRead();
QByteArray incomingContent=socket->readAll();
socket->appendData(incomingContent);
}
if (socket->getBytesHaveRead() > (16*1024*1024))
{
socket->getResponse().setStatusCode(400);
socket->getResponse() << "maximum message size above 16mb.";
socket->getResponse().finish();
socket->waitForBytesWritten();
socket->close();
}
else
if(socket->isEof())
{
PathTreeNode::HttpVerb handlerType;
if(m_parser.method==HTTP_GET)
{
socket->getHeader().setHttpMethod(HttpHeader::HttpMethod::HTTP_GET);
handlerType=PathTreeNode::GET;
}
else if(m_parser.method==HTTP_POST)
{
socket->getHeader().setHttpMethod(HttpHeader::HttpMethod::HTTP_POST);
handlerType=PathTreeNode::POST;
}
else
{
qDebug()<<"not get and post"<<socket->atEnd()<<socket->bytesAvailable()<<socket->ConnectedState;
socket->close();
return;
}
socket->getRequest().processCookies();
socket->getRequest().parseFormData();
//qDebug() << "path" << socket->getRequest().getHeader().getPath();
#ifndef NO_LOG
sLog() << "handle request:" << socket->getRequest().getHeader().getPath();
qDebug() << "handle request:" << socket->getRequest().getHeader().getPath();
#endif
if (!m_consolePath.isEmpty() && m_consolePath == socket->getRequest().getHeader().getPath())
{
handleConsole(socket->getRequest(), socket->getResponse());
socket->getResponse().finish();
}
else
{
const std::function<void (HttpRequest &, HttpResponse &)> &th = m_pathTree->getTaskHandlerByPath(socket->getRequest().getHeader().getPath(), handlerType);
if(th)
{
th(socket->getRequest(), socket->getResponse());
socket->getResponse().finish();
}
else
{
#ifndef NO_LOG
qDebug()<<"empty task handler!" << socket->getRequest().getHeader().getPath() << ";" <<handlerType;
sLog()<<"empty task handler!" << socket->getRequest().getHeader().getPath() << ";" <<handlerType;
#endif
socket->getResponse().setStatusCode(404);
socket->getResponse().finish();
}
}
socket->waitForBytesWritten();
socket->close();
}
else
{
qDebug()<<"socket size:"<<socket->getTotalBytes()<<"current size:"<<socket->getBytesHaveRead();
return;
}
}
}
