void IOUtil::createSocketPair(int pair[2]) throw (IOException&)
{
#if defined(WIN32)
Socket connectSocket;
Socket serverClientSocket;
ServerSocket listenSocket;
SocketAddress loopback = SocketAddress::loopback(AF_INET, 0);
listenSocket.listen(loopback, 5, false);
connectSocket.connect(listenSocket.getLocalAddress(), true);
if (!listenSocket.accept(serverClientSocket))
{
THROW2(IOException, "Can't accept for socket pair");
}
pair[0] = connectSocket.detach();
pair[1] = serverClientSocket.detach();
#else
if (0 != ::socketpair(AF_LOCAL, SOCK_STREAM, 0, pair))
{
THROW2(IOException, "Can't create socket pair");
}
#endif
}
int main (int argc, char* argv[]) {
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = &sig_handler;
sigaction(SIGINT, &sa, NULL);
IniParser* ini = new IniParser("server.ini");
documentRoot = ini->get("document_root");
std::string port = ini->get("port");
delete(ini);
ServerSocket* server = new ServerSocket(port);
ClientSocket* client = NULL;
while (!stop) {
client = server->accept(true);
if (client != NULL) {
pthread_t tid;
pthread_create(&tid, NULL, &clientThread, client);
pthread_detach(tid);
}
}
delete(server);
std::cout << "Shutdown complete." << std::endl;
return 0;
}
int main (){
cout << "server running...." << endl;
try{
ServerSocket server ( 30000 ); // Create main server socket
while ( true ){ // server runs forever
ServerSocket new_sock; // bind user socket to port and listen
server.accept ( new_sock );
printUsage();
try{
while ( true ){
char command[256]; //user input
string reply; //command from client
cout << "> ";
cin.getline(command,256);
if (strlen(command) == 0) //re-prompt user if input is empty
continue;
new_sock << string(command); //send command to create
new_sock >> reply; //read confirmation
cout << reply <<endl;
}
}catch ( SocketException& ) {}
}
}
catch ( SocketException& e ){
cout << "Exception was caught:" << e.description() << endl << "Exiting.";
}
return 0;
}
int main(int argc, const char * argv[])
{
m_g = make_shared<Game>(Game());
// start command consumer thread
thread consumer {consume_command};
// keep client threads here, so we don't need to detach them
vector<thread> handlers;
// create a server socket
ServerSocket server {machiavelli::tcp_port};
while (true) {
try {
while (true) {
// wait for connection from client; will create new socket
cerr << "server listening" << '\n';
unique_ptr<Socket> client {server.accept()};
// communicate with client over new socket in separate thread
thread handler {handle_client, move(client)};
handlers.push_back(move(handler));
}
} catch (const exception& ex) {
cerr << ex.what() << ", resuming..." << '\n';
} catch (...) {
cerr << "problems, problems, but: keep calm and carry on!\n";
}
}
return 0;
}
int main()
{
/*
StdWriteRead stdWriteRead;
runloop.registerReadIntent(fileno(stdin), &stdWriteRead);
runloop.run();
*/
/*
try
{
RunLoop runloop;
Socket socket;
socket.connect("localhost", 22, false);
int sock = socket.getSocket();
StdWriteRead stdWriteRead(sock);
runloop.registerReadIntent(sock, &stdWriteRead);
runloop.run();
}
catch ( std::runtime_error r )
{
fprintf(stderr, r.what());
}
*/
ServerSocket serverSocket;
serverSocket.listen("0.0.0.0", 3000, 10);
std::string ip;
serverSocket.accept(&ip, NULL);
printf("socket: %s\n", ip.c_str());
}
int main(){
Database db("database");
//listening requests
try{
// Create the socket
ServerSocket server ( 30000 );
while(true){
ServerSocket new_sock;
server.accept (new_sock);
try{
std::string data;
new_sock >> data;
std::string *res = db.request(data);
new_sock << *res;
delete res;
}catch (SocketException& e){
std::cout << "Something go wrong: " << e.description() << "\nExiting.\n";
}
}
}
catch (SocketException& e){
std::cout << "Something go wrong: " << e.description() << "\nExiting.\n";
}
return 0;
}
bool accept(int port, string address = "0")
{
inactiveTime = 0;
ServerSocket* serverSocket = new ServerSocket();
socket = serverSocket;
return serverSocket->accept(port, address);
}
int main ( int argc, int argv[] )
{
std::cout << "running....\n";
try
{
// Create the socket
ServerSocket server ( 6006 );
while ( true )
{
ServerSocket new_sock;
server.accept ( new_sock );
try
{
while ( true )
{
char *data;
//new_sock >> data;
new_sock << "Mesaje";
}
}
catch ( SocketException& ) {}
}
}
catch ( SocketException& e )
{
cout << "Exception was caught:" << e.description() << "\nExiting.\n";
}
return 0;
}
virtual void run(){
try{
unsigned char buf[1000];
ServerSocket server;
server.bind( "127.0.0.1", SocketFactoryTest::DEFAULT_PORT );
net::Socket* socket = server.accept();
server.close();
socket->setSoLinger( false, 0 );
synchronized(&mutex)
{
numClients++;
mutex.notifyAll();
}
while( !done && socket != NULL ){
io::InputStream* stream = socket->getInputStream();
memset( buf, 0, 1000 );
try{
if( stream->read( buf, 1000, 0, 1000 ) == -1 ) {
done = true;
continue;
}
lastMessage = (char*)buf;
if( strcmp( (char*)buf, "reply" ) == 0 ){
io::OutputStream* output = socket->getOutputStream();
output->write( (unsigned char*)"hello", (int)strlen("hello"), 0, (int)strlen("hello") );
}
}catch( io::IOException& ex ){
done = true;
}
}
socket->close();
delete socket;
numClients--;
synchronized(&mutex) {
mutex.notifyAll();
}
}catch( io::IOException& ex ){
printf("%s\n", ex.getMessage().c_str() );
CPPUNIT_ASSERT( false );
}catch( ... ){
CPPUNIT_ASSERT( false );
}
}
static int _main(int argc, char **argv) {
vector<string> args(argc-1);
for (int i=1; i<argc; ++i) {
args[i-1] = argv[i];
}
args.at(0);
//YaoProtocol yao;
Socket *s;
ifstream fmtin("/home/louis/sfe/priveq.fmt");
FmtFile fmt = FmtFile::parseFmt(fmtin);
cout << "Read fmt file" << endl;
ifstream in("/home/louis/sfe/priveq.circ");
Circuit_p cc = Circuit::parseCirc(in);
if (args[0] == ("A")) {
args.at(1);
BigInt n = BigInt::parseString(args[1]);
bit_vector input_bits = toBits(n, fmt.numInputs(0));
cout << "connecting" << endl;
s = new Socket("localhost", 5437);
DataOutput *out = s->getOutput();
DataInput *in = s->getInput();
YaoSender cli;
cli.setStreams(in, out);
cli.go(cc, fmt, input_bits);
delete out;
delete in;
delete s;
} else if (args[0] == ("B")) {
args.at(1);
BigInt n = BigInt::parseString(args[1]);
bit_vector input_bits = toBits(n, fmt.numInputs(1));
args.at(1);
YaoChooser srv;
cout << "listening" << endl;
ServerSocket *ss = new ServerSocket(5437);
s = ss->accept();
DataOutput *out = s->getOutput();
DataInput *in = s->getInput();
srv.setStreams(in, out);
bit_vector circ_out = srv.go(cc, fmt, input_bits);
for (uint i=0; i<circ_out.size(); ++i) {
cout << "output " << i << ": " << circ_out[i] << endl;
}
delete s;
delete ss;
delete out;
delete in;
}
return 0;
}
int main ( int argc, char **argv )
{
std::cout << "running....\n"; //Indicate that the server is running
refreshSnippets(); //refresh the snippets to make sure everything is running properly
//Error handling for creating the sockets
try
{
// Create the socket
ServerSocket server (7777);
while (true)
{
ServerSocket serverSocket; //Create the server socket
server.accept (serverSocket);
//Error handling for receiving the data
try { while(true)
{
string input; //Input variable from the client
serverSocket > input; //Direct the input from the socket to the variable
//Check for a certain flag
if(input == "-i")
{
// Write the reply back to the client
serverSocket << "Snippet inserted";
while(1) //While true
{
string snippetIn; //String variable for incoming snippet
serverSocket > snippetIn; //Redirect the socket data to the variable
if(snippetIn == "\0") break; //Check to see if we have a terminating character
writeMessage(snippetIn.c_str()); //If not, write the serialized data to a file
updateDesktopFile(); //Refresh the desktop file
}
};
//Check for certain flags
if(input == "-c")
{
serverSocket << "Snippets Cleared"; //Let the client know the server was cleared
ofstream myfile ("snippet.txt"); //Open file without append flags
myfile << "\n";
myfile.close(); // Close file
updateDesktopFile(); //Update desktop file
};
}// end while(true)
}
//Catch any exception thrown by the socket
catch ( SocketException& ){}
}//Close the top while(true)
}// close try
//Catch any exception thrown by the socket while exiting
catch ( SocketException& e ) {std::cout << "Exception " << e.description() << "\n while the socket was Exiting.\n";};
return 0;
}
//this thread handles socket connection to the network
void * ServerThread(void * str)
{
printf("ServerThread Started \n");
CHKcon=0;
// Create the socket
ServerSocket server ( 30000 );
while(true)
{
ServerSocket new_sock;
server.accept ( new_sock );//start listening to port 30000
try
{
//cvNamedWindow("thresh");/////////////delet it
while (true)
{
////////////ball tracking
//IplImage frame0;
//frame0=img0;
//IplImage* imgHSV = cvCreateImage(cvGetSize(&frame0),8,3);
//cvCvtColor(&frame0,imgHSV, CV_BGR2HSV);
//IplImage* imgThreshed= cvCreateImage(cvGetSize(&frame0),8,1);
//cvInRangeS(imgHSV,cvScalar(20,100,100),cvScalar(30,255,255),imgThreshed);
//cvReleaseImage(&imgHSV);
//////////////////////
std::string data;
new_sock >> data;
if(data.length()>2)
if((data[0]=='*')&&(data[1]=='#')&&(data[data.length()-1]=='*'))
{
CHKcon=0;//resets connection check timer
switch (data[2])
{
case 'M'://Motors instruction
if(data.length()==6)
{
//printf("%d %d \n",int(data[3])-128,int(data[4])-128);
runmotors((int(data[3])-64)*4,(int(data[4])-64)*4);
}
break;
case 'S':
festivalst= data.substr(3,data.length()-4);
break;
}
}
new_sock << data;
}
}
catch ( SocketException& ) {}
usleep(1000);
}
}
int run() {
groomLogFile();
if (runMode.compare("daemon") == 0) {
dup2(ferr, 2);
dup2(2, 1);
}
port = config["port"];
ServerSocket* ss = NULL;
debug = 1;
b64_hmt = base64_encode((const unsigned char*) JPEGImage::StdHuffmanTable, 420, (size_t*) & b64_hmt_l);
WSServer* wss = new WSServer(
config["hostName"],
config["lwsDebug"],
config["HTTPPort"],
config["HTTPSPort"],
config["sslCert"],
config["sslKey"],
config["sslCA"]
);
try {
ss = new ServerSocket(port);
} catch (SocketException e) {
ffl_err(FPL_MAIN, "Unable to create socket on port: %d", port);
}
while (ss && !force_exit && (duration == 0 || duration > (time(NULL) - starttime))) {
try {
ffl_notice(FPL_MAIN, "waiting for a connection on %d ...", port);
FerryStream* fs = new FerryStream(ss->accept(),
&ferryStreamFuneral);
cleanDeadFSList();
ffl_notice(FPL_MAIN, "a connection accepted.");
} catch (SocketException e) {
ffl_warn(FPL_MAIN, "Exception accepting incoming connection: %s",
e.description().c_str());
} catch (FerryStream::Exception e) {
ffl_err(FPL_MAIN, "Exception creating a new FerryStream: %s",
e.what());
}
}
force_exit = 1;
sleep(5);
cleanDeadFSList();
cleanLiveFSList();
delete ss;
delete wss;
terminate_all_paths();
free(b64_hmt);
ffl_notice(FPL_MAIN, "BYE!");
return 0;
}
void Communication()
{
try
{
// Create the socket
ServerSocket server (port);
int rounds = 16;
string rStr = "";
while ( true )
{
//ServerSocket new_sock;
server.accept (new_sock);
stop = false;
weFinish = false;
try
{
while ( true )
{
std::string data;
cout << "Waiting for command..." << endl;
new_sock >> data;
cout << "Received :: " << data << endl;
if(data != "Stop")
{
rounds = std::stoi(data);
std::thread (ExecuteThreads_high, rounds).detach();
std::thread (checkFinish).detach();
cout << "Started Computing..." << endl;
}
else
{
cout << "Stopped... Check at other server for answer" << endl;
stop = true;
break;
}
}
}
catch ( SocketException& e) {
//cout << e.description()<< endl;
}
cout << "------------ Completed Successfully ---------------\n";
}
}
catch ( SocketException& e )
{
cout << "Exception was caught:" << e.description() << "\nExiting.\n";
}
}
int main(int argc,char **argv) {
cout << "running...." << endl;
ServerSocket *server;
try
{
server = new ServerSocket(30000); // 等待client連線
}
catch ( SocketException& e )
{
cout << "Exception was caught:" << e.description() << "\nExiting.\n";
return -1;
}
while(true)
{
try
{
struct imagedata image;
// 把第一個資料填入
memset(&image,1,sizeof(struct imagedata)); // 不可以填0,否則會出現錯誤,可能是所有成員都必需要有資料
image.r_pixel[0][0]='P'; // 先填一個數值進去,到client端再讀取出來,看是否有錯誤
// 把資料寫到before - start
FILE *fp;
fp = fopen("before","wb");
fwrite(&image,1,sizeof(struct imagedata),fp);
fclose(fp);
// 把資料寫到before - end
char data[MAXRECV];
while(true)
{
memset(data,0,MAXRECV);
//*server >> data;
//::SDFile(server,"realalt180.exe");
::SDStruct(server,(char*)&image); // 送資料
printf("%s\n",data);
}
}
catch (SocketException &)
{
server->close_connfd();
server->accept();
}
}
return 0;
}
int main ( int argc, char* argv[] )
{
std::cout << "running....\n";
try
{
// Create the socket
// ServerSocket server ( 30000 );
ServerSocket server (12354);
while ( true )
{
ServerSocket new_sock;
server.accept ( new_sock );
try
{
while ( true )
{
std::string data;
new_sock >> data;
std::cout << data << std::endl;
ofstream outfile("/home/kora/桌面/log.txt", ios::app);
outfile << data << endl;
outfile.close();
new_sock << data;
}
}
catch ( SocketException& ) {}
}
}
catch ( SocketException& e )
{
std::cout << "Exception was caught:" << e.description() << "\nExiting.\n";
}
return 0;
}
int main(int argc, int argv[]) {
std::cout << "running....\n";
Message message("topas", "Hello World"), m2("topas", "where are you?"),
m3("guest", "Hi");
MessageStack messages;
messages.append(&message);
messages.append(&m2);
messages.append(&m3);
pthread_t tid;
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
try {
pthread_create(&tid, &attr, &game, NULL);
while (true) {
try{
ServerSocket *new_sock = new ServerSocket;
server.accept(*new_sock);
pthread_create(&tid, &attr, &rundle, new_sock);
}
catch (SocketException& e) {
std::cout << "Exception was caught:" << e.description()
<< "\nExiting.\n";
}
}
} catch (SocketException& e) {
std::cout << "Exception was caught:" << e.description()
<< "\nExiting.\n";
}
return 0;
}
int main ( int argc, int argv[] )
{
std::cout << "running....\n" << std::flush;
try
{
// Create the socket
ServerSocket server ( 30000 );
while ( true )
{
ServerSocket new_sock;
server.accept ( new_sock );
try
{
while ( true )
{
std::string data;
new_sock >> data;
std::cout << data << std::flush;
new_sock << data;
}
}
catch ( SocketException& )
{
}
}
}
catch ( SocketException& e )
{
std::cout << "Exception was caught:" << e.description() << "\nExiting.\n";
}
return 0;
}
TEST(Sockets, data) {
ServerSocket ssck;
ssck.bind(1337);
NetworkAddress addr1("127.0.0.1", 1337);
Socket sck1;
sck1.connect(addr1);
Socket* sck2 = ssck.accept();
std::string lipsum = TestHelper::getLoremIpsum();
uint8_t* data = (uint8_t*) lipsum.data();
unsigned int len = (unsigned int) lipsum.size();
SocketInputStream* s1in = sck1.getInputStream();
SocketOutputStream* s2out = sck2->getOutputStream();
s2out->write(128);
ASSERT_EQ(128, s1in->read());
s2out->write(data, len);
for (unsigned int i = 0; i < len; ++i) {
ASSERT_EQ(data[i], s1in->read());
}
s1in->close();
ASSERT_THROW(s1in->read(), SocketException);
s2out->write(128);
ASSERT_THROW(s2out->write(128), SocketException);
//ASSERT_EQ(-1, s1in.read());
delete sck2;
}
int main ( int argc, int argv[] )
{
std::cout << "running....\n";
try
{
// Create the socket
ServerSocket server ( 44444 );
while ( true )
{
ServerSocket new_sock;
server.accept ( new_sock );
try
{
while ( true )
{
std::string data;
new_sock >> data;
std::cout << "Received this response from client:\n\"" << data << "\"\n";;
new_sock << data;
}
}
catch ( SocketException& ) {}
}
}
catch ( SocketException& e )
{
std::cout << "Exception was caught:" << e.description() << "\nExiting.\n";
}
return 0;
}
void* APR_THREAD_FUNC SocketHubAppender::monitor(apr_thread_t* /* thread */, void* data) {
SocketHubAppender* pThis = (SocketHubAppender*) data;
ServerSocket* serverSocket = 0;
try
{
serverSocket = new ServerSocket(pThis->port);
serverSocket->setSoTimeout(1000);
}
catch (SocketException& e)
{
LogLog::error(LOG4CXX_STR("exception setting timeout, shutting down server socket."), e);
delete serverSocket;
return NULL;
}
bool stopRunning = pThis->closed;
while (!stopRunning)
{
SocketPtr socket;
try
{
socket = serverSocket->accept();
}
catch (InterruptedIOException&)
{
// timeout occurred, so just loop
}
catch (SocketException& e)
{
LogLog::error(LOG4CXX_STR("exception accepting socket, shutting down server socket."), e);
stopRunning = true;
}
catch (IOException& e)
{
LogLog::error(LOG4CXX_STR("exception accepting socket."), e);
}
// if there was a socket accepted
if (socket != 0)
{
try
{
InetAddressPtr remoteAddress = socket->getInetAddress();
LogLog::debug(LOG4CXX_STR("accepting connection from ")
+ remoteAddress->getHostName()
+ LOG4CXX_STR(" (")
+ remoteAddress->getHostAddress()
+ LOG4CXX_STR(")"));
// add it to the oosList.
synchronized sync(pThis->mutex);
OutputStreamPtr os(new SocketOutputStream(socket));
Pool p;
ObjectOutputStreamPtr oos(new ObjectOutputStream(os, p));
pThis->streams.push_back(oos);
}
catch (IOException& e)
{
LogLog::error(LOG4CXX_STR("exception creating output stream on socket."), e);
}
}
stopRunning = (stopRunning || pThis->closed);
}
delete serverSocket;
return NULL;
}
void ManagerServer::run()
{
bool running = true;
bool *move = new bool[4] {{0}};
bool shoot = 0;
bool gift1 = 0;
bool gift2 = 0;
sf::Event event;
gui->getWindow()->clear();
if(gui->drawMenu(menu))
{
while (running)
{
std::string dataServer = " ";
std::string dataClient;
std::cout << "running....\n";
try
{
//Create the socket
ServerSocket server ( 30000 );
ServerSocket server_socket;
server.accept ( server_socket );
try
{
while(gui->getWindow()->pollEvent(event))
{
switch(event.type)
{
case sf::Event::Closed:
{
gui->getWindow()->close();
return;
}
case sf::Event::KeyPressed:
{
switch(event.key.code)
{
case sf::Keyboard::Right:
{
move[0]=1;
break;
}
case sf::Keyboard::Up:
{
move[1]=1;
break;
}
case sf::Keyboard::Left:
{
move[2]=1;
break;
}
case sf::Keyboard::Down:
{
move[3]=1;
break;
}
case sf::Keyboard::Space:
{
shoot=1;
break;
}
}
break;
}
case sf::Event::KeyReleased:
{
switch(event.key.code)
{
case sf::Keyboard::Right:
{
move[0]=0;
break;
}
case sf::Keyboard::Up:
{
move[1]=0;
break;
}
case sf::Keyboard::Left:
{
move[2]=0;
break;
}
case sf::Keyboard::Down:
{
move[3]=0;
break;
}
/*case sf::Keyboard::Space:
{
shoot=0;
break;
}*/
}
break;
}
}
}
dataServer = bomber2->move2(move ,obs , wall ,bomber1);
if(shoot)
{
dataServer = bomb2->shoot2(bomber2 , bomb2timer);
shoot=0;
}
server_socket >> dataClient;
server_socket << dataServer;
bomber1->move1(dataClient , obs , wall , bomber2);
bomb1->shoot1(dataClient , bomber1 , bomb1timer);
for(int i=0; i<6 ; i++)
{
if ( gift[i].getGift(bomber1) == 1)
gift1 = 1;
if ( gift[i].getGift(bomber2) == 1)
gift2 = 1;
}
gui->drawBack();
gui->drawBomber(bomber1,true);
gui->drawBomber(bomber2,false);
gui->drawWall(wall);
gui->drawTimer(timer);
gui->drawGift(gift);
gui->drawObs(obs);
if(bomb1timer->getSeconds()<4)
bomb1timer->handletime();
if(bomb2timer->getSeconds()<4)
bomb2timer->handletime();
if(bomb1timer->getSeconds()>=1 && bomb1timer->getSeconds()<=3)
{
gui->drawBomb(bomb1);
}
if(bomb1timer->getSeconds()==3)
{
sf::Music b;
if (!b.openFromFile("howto.wav")) {}
b.play();
if(gift1 == 1)
{
bomb1->explodeGift(obs , bomber1 ,bomber2);
}
bomb1->explode(obs , bomber1 ,bomber2);
}
if(bomb2timer->getSeconds()>=1 && bomb2timer->getSeconds()<=3)
{
gui->drawBomb(bomb2);
}
if(bomb2timer->getSeconds()==3)
{
sf::Music b;
if (!b.openFromFile("howto.wav")) {}
b.play();
if(gift2 == 1)
{
bomb2->explodeGift(obs , bomber1 ,bomber2);
}
bomb2->explode(obs , bomber1 ,bomber2);
}
if(bomber2->getIsExist()==0 && bomber1->getIsExist()==1){gui->drawGameover();}
if(bomber2->getIsExist()==1 && bomber1->getIsExist()==0){gui->drawWin();}
gui->getWindow()->display();
server_socket >> dataClient;
server_socket << dataServer;
}
catch ( SocketException& ) { std::cout << "error " ;}
}
catch ( SocketException& e )
{
//gui->drawLoading();
//gui->getWindow()->display();
std::cout << "Exception was caught:" << e.description() << "\nExiting.\n";
}
}
}
}
int main ( int argc, char *argv[] ){
//cout << "running....\n";
try{
// Create the socket
ServerSocket server ( 30000 );
Aria::init();
Arnl::init();
ArRobot robot;
ArArgumentParser parser(&argc, argv);
parser.loadDefaultArguments();
ArSonarDevice sonar;
ArSimpleConnector simpleConnector(&parser);
// Our server for mobile eyes
ArServerBase moServer;
// Set up our simpleOpener
ArServerSimpleOpener simpleOpener(&parser);
parser.loadDefaultArguments();
if (!Aria::parseArgs () || !parser.checkHelpAndWarnUnparsed()){
Aria::logOptions ();
Aria::exit (1);
}
//Add the sonar to the robot
robot.addRangeDevice(&sonar);
// Look for map in the current directory
ArMap arMap;
// set it up to ignore empty file names (otherwise the parseFile
// on the config will fail)
arMap.setIgnoreEmptyFileName (true);
// First open the server
if (!simpleOpener.open(&moServer)){
if (simpleOpener.wasUserFileBad())
ArLog::log(ArLog::Normal, "Bad user file");
else
ArLog::log(ArLog::Normal, "Could not open server port");
exit(2);
}
// Connect to the robot
if (!simpleConnector.connectRobot (&robot)){
ArLog::log (ArLog::Normal, "Could not connect to robot... exiting");
Aria::exit (3);
}
// Create the localization task (it will start its own thread here)
ArSonarLocalizationTask locTask(&robot, &sonar, &arMap);
ArLocalizationManager locManager(&robot, &arMap);
ArLog::log(ArLog::Normal, "Creating sonar localization task");
locManager.addLocalizationTask(&locTask);
// Set the initial pose to the robot's "Home" position from the map, or
// (0,0,0) if none, then let the localization thread take over.
locTask.localizeRobotAtHomeNonBlocking();
//Create the path planning task
ArPathPlanningTask pathTask(&robot,&sonar,&arMap);
ArLog::log(ArLog::Normal, "Robot Server: Connected.");
robot.enableMotors();
robot.clearDirectMotion();
// Start the robot processing cycle running in the background.
// True parameter means that if the connection is lost, then the
// run loop ends.
robot.runAsync(true);
// Read in parameter files.
Aria::getConfig ()->useArgumentParser (&parser);
if (!Aria::getConfig ()->parseFile (Arnl::getTypicalParamFileName ())){
ArLog::log (ArLog::Normal, "Trouble loading configuration file, exiting");
Aria::exit (5);
}
//Create the three states
robot.lock();
Follow follow = Follow(&robot,&sonar);
GoTo goTo(&robot,&pathTask,&arMap);
Search s(&robot,&sonar);
// Bumpers.
ArBumpers bumpers;
robot.addRangeDevice(&bumpers);
pathTask.addRangeDevice(&bumpers, ArPathPlanningTask::CURRENT);
// Forbidden regions from the map
ArForbiddenRangeDevice forbidden(&arMap);
robot.addRangeDevice(&forbidden);
pathTask.addRangeDevice(&forbidden, ArPathPlanningTask::CURRENT);
// Mode To stop and remain stopped:
ArServerModeStop modeStop(&moServer, &robot);
// Action to slow down robot when localization score drops but not lost.
ArActionSlowDownWhenNotCertain actionSlowDown(&locTask);
pathTask.getPathPlanActionGroup()->addAction(&actionSlowDown, 140);
// Action to stop the robot when localization is "lost" (score too low)
ArActionLost actionLostPath(&locTask, &pathTask);
pathTask.getPathPlanActionGroup()->addAction(&actionLostPath, 150);
// These provide various kinds of information to the client:
ArServerInfoRobot serverInfoRobot(&moServer, &robot);
ArServerInfoSensor serverInfoSensor(&moServer, &robot);
ArServerInfoPath serverInfoPath(&moServer, &robot, &pathTask);
// Provide the map to the client (and related controls):
// This uses both lines and points now, since everything except
// sonar localization uses both (path planning with sonar still uses both)
ArServerHandlerMap serverMap(&moServer, &arMap);
// Provides localization info and allows the client (MobileEyes) to relocalize at a given
// pose:
ArServerInfoLocalization serverInfoLocalization(&moServer, &robot, &locTask);
ArServerHandlerLocalization serverLocHandler(&moServer, &robot, &locTask);
robot.unlock();
moServer.runAsync();
//Main loop
while (true){
//The socket to accept connection
ServerSocket new_sock;
server.accept ( new_sock );
int state = 1; //1 = Follow, 2 = Search, 3 = GoTo
int lastPos[2]; //Storing last position of BB to search the target
int data[2]; //matrix with X,Y of BB
try{
while ( true ){
//receive data from tld
new_sock >> data;
//cout << data[0] << "," << data[1] << endl;
if(data[0] != -1)
lastPos[0] = data[0];
//cout << state <<endl; //for debugging
//Main logic
switch(state){
case 1:
cout << "Following target\n";
state = follow.run(data);
break;
case 2:
cout << "Searching for target\n";
state = s.seek(lastPos, data);
break;
case 3:
cout << "Going to ...\n";
state = goTo.run(data);
break;
default:
cout << "Not a case for state\n";
break;
}
std::cout << "Loc score: " << locTask.getLocalizationScore() << std::endl;
}
}
catch ( SocketException& ) {
cout << "Lost Connection" << endl;
robot.lock();
robot.stop();
robot.unlock();
}
}
}
catch ( SocketException& e ){
std::cout << "Exception was caught:" << e.description() << "\nExiting.\n";
}
ArLog::log(ArLog::Normal, "RobotServer: Exiting.");
return 0;
}
int main(int argc, char *argv[])
{
LogFile log("test.log");
log << "**************************"
<< "New server session started";
Address addr(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if(!addr.getHost(HOST, PORT))
{
logHost(log, "Unable to resolve");
return 1;
}
else
{
logHost(log, "Resolved");
}
ServerSocket server;
if(server.bind(addr) <= 0)
{
logHost(log, "Unable to bind to");
return 2;
}
else
{
logHost(log, "Bound to");
}
cout << "Server FD: " << server << endl;
if(!server.listen(10))
{
logHost(log, "Unable to listen on");
return 3;
}
else
{
logHost(log, "Listening on");
cout << "Listening on " << HOST << ":" << PORT << endl;
}
// Client and select poll structure setup
//vector<ClientSocket> clients;
map<int, unique_ptr<ClientSocket>> table;
map<int, string> names;
Multiplexer select;
server.setNonBlock(1);
select.insert(server);
Galaxy galaxy;
while(true)
{
if(select.poll() == -1)
{
cerr << "select.poll() error\n";
break;
}
for(int i = 0; i < FD_SETSIZE; ++i)
{
if(select.setRead(i))
{
if(server == i)
{
ClientSocket *client = new ClientSocket(server.accept());
if(client)
{
client->setNonBlock(1);
select.insert(*client);
table[*client] = unique_ptr<ClientSocket>(client);
}
else
log << "A client was rejected from the server";
continue;
}
char buf[256];
int bytes = recv(i, &buf[0], 255, 0);
if(bytes <= 0)
{
table[i]->close();
galaxy.rmPlayer(names[i]);
select.eradicate(i);
continue;
}
buf[bytes] = '\0';
string buffer(buf);
cout << "Client: " << buffer;
auto pos = buffer.find(':');
if(buffer.substr(0, pos) == "Login")
{
string name = buffer.substr(pos + 1,
buffer.size() - pos);
Player *p;
try { p = &galaxy.newPlayer(name); }
catch(...)
{
table[i]->close();
select.eradicate(i);
}
names[i] = name;
string planet = "Planet:" + to_string(p->world().x())
+ ":" + to_string(p->world().y()) + "\n";
table[i]->write(planet.c_str());
}
// End of client handler block
}
}
}
for(auto& client : table)
{
if(client.second > 0)
client.second->close();
}
return 0;
}
void FileTransferSocketThread::execute()
{
if(info.hostType == eServer)
{
ServerSocket serverSocket;
serverSocket.bind(this->info.serverPort);
serverSocket.listen(1);
Socket *clientSocket = serverSocket.accept();
char data[513]="";
memset(data, 0, 256);
clientSocket->receive(data,256, true);
if(*data == SEND_FILE)
{
FileInfo file;
memcpy(&file, data+1, sizeof(file));
*data=ACK;
clientSocket->send(data,256);
Checksum checksum;
checksum.addFile(file.fileName);
file.filecrc = checksum.getSum();
ifstream infile(file.fileName.c_str(), ios::in | ios::binary | ios::ate);
if(infile.is_open() == true)
{
file.filesize = infile.tellg();
infile.seekg (0, ios::beg);
memset(data, 0, 256);
*data=SEND_FILE;
memcpy(data+1,&file,sizeof(file));
clientSocket->send(data,256);
clientSocket->receive(data,256, true);
if(*data != ACK) {
//transfer error
}
int remain=file.filesize % 512 ;
int packs=(file.filesize-remain)/512;
while(packs--)
{
infile.read(data,512);
//if(!ReadFile(file,data,512,&read,NULL))
// ; //read error
//if(written!=pack)
// ; //read error
clientSocket->send(data,512);
clientSocket->receive(data,256, true);
if(*data!=ACK) {
//transfer error
}
}
infile.read(data,remain);
//if(!ReadFile(file,data,remain,&read,NULL))
// ; //read error
//if(written!=pack)
// ; //read error
clientSocket->send(data,remain);
clientSocket->receive(data,256, true);
if(*data!=ACK) {
//transfer error
}
infile.close();
}
}
delete clientSocket;
}
else
{
Ip ip(this->info.serverIP);
ClientSocket clientSocket;
clientSocket.connect(this->info.serverIP, this->info.serverPort);
if(clientSocket.isConnected() == true)
{
FileInfo file;
file.fileName = this->info.fileName;
//file.filesize =
//file.filecrc = this->info.
string path = extractDirectoryPathFromFile(file.fileName);
createDirectoryPaths(path);
ofstream outFile(file.fileName.c_str(), ios_base::binary | ios_base::out);
if(outFile.is_open() == true)
{
char data[513]="";
memset(data, 0, 256);
*data=SEND_FILE;
memcpy(data+1,&file,sizeof(file));
clientSocket.send(data,256);
clientSocket.receive(data,256, true);
if(*data!=ACK) {
//transfer error
}
clientSocket.receive(data,256,true);
if(*data == SEND_FILE)
{
memcpy(&file, data+1, sizeof(file));
*data=ACK;
clientSocket.send(data,256);
int remain = file.filesize % 512 ;
int packs = (file.filesize-remain) / 512;
while(packs--)
{
clientSocket.receive(data,512,true);
outFile.write(data, 512);
if(outFile.bad())
{
//int ii = 0;
}
//if(!WriteFile(file,data,512,&written,NULL))
// ; //write error
//if(written != pack)
// ; //write error
*data=ACK;
clientSocket.send(data,256);
}
clientSocket.receive(data,remain,true);
outFile.write(data, remain);
if(outFile.bad())
{
//int ii = 0;
}
//if(!WriteFile(file,data,remain,&written,NULL))
// ; //write error
//if(written!=pack)
// ; //write error
*data=ACK;
clientSocket.send(data,256);
Checksum checksum;
checksum.addFile(file.fileName);
uint32 crc = checksum.getSum();
if(file.filecrc != crc)
{
//int ii = 0;
}
//if(calc_crc(file)!=info.crc)
// ; //transfeer error
}
outFile.close();
}
}
}
}
int main ( int argc, char** argv )
{
if(argc !=2)
std::cout <<"Usage ./server <DbFilename>\n";
FileStorage Db(static_cast<std::string>(argv[1]));
// register the storage system
database.registerStorage(&Db);
// load the data from storage if any
database.loadDataFromStorage();
// register for signal handler
registerSignal();
try
{
std::cout << "Server starting on port 15000....\n";
ServerSocket server ( 15000 );
while ( true )
{
ServerSocket server_sock;
server.accept ( server_sock );
try
{
while ( true )
{
std::string input;
server_sock >> input;
std::string key,value;
std::string result;
// remove the last \r\n from input string
input.erase(input.size()-2);
// space for storing the tokens from input string
std::vector<std::string> token;
std::fill(token.begin(), token.end(), "");
// Parse the input and tokenize it and store in vector for further use
std::stringstream ss(input);
std::string s;
while (getline(ss, s, ' ')) {
token.push_back(s);
}
// Parese rest of input based on first token {SET,GET,SAVE}
switch(hashit(token[0]))
{
case GET:
if (2 != token.size())
goto INVALID;
key = token[1];
result = database.get(key);
// Return the result of GET query
server_sock <<"$3\n";
server_sock << result <<"\n";
break;
case SET:
if (3 != token.size())
goto INVALID;
key = token[1];
value = token[2];
// Store the SET query in memory
database.add(key,value);
server_sock <<"+OK\n";
break;
case SAVE:
if (1 != token.size())
goto INVALID;
database.persistData();
server_sock <<"+OK\n";
break;
INVALID:
default:
server_sock << "-INVALID\n";
break;
}
}
}
catch ( SocketException& ) {}
}
}
catch ( SocketException& e )
{
std::cout << "Exception was caught:" << e.description() << "\nExiting.\n";
}
return 0;
}
int main ( int argc, int argv[] )
{
LaserDriver LD;
std::cout << "running....\n";
try
{
// Create the socket
ServerSocket server ( 30000 );
vector< vector< int > > points;
while ( true )
{
ServerSocket new_sock;
server.accept ( new_sock );
server.set_non_blocking( false );
string buffer = "";
try
{
while ( true ){
points.erase( points.begin(), points.begin()+points.size());
cout << "here1" << endl;
std::string line = "";
//std::string buffer="";
int x, y;
while( true ){
new_sock >> buffer;
stringstream bss;
bss << buffer;
int sentinel = 0;
int prev_numb = 0;
int number = 0;
bool first = true;
bool done = false;
while( bss >> sentinel ){
bss >> number;
if (sentinel < 0 || number < 0){
done = true;
break;
}
else{
vector<int> pts;
pts.push_back(sentinel);
pts.push_back(number);
points.push_back(pts);
}
}
if( done )
break;
}
// if( line.length() > 0 ){
// cout << "reading..." << endl;
// points.erase( points.begin(), points.begin()+points.size() );
// std::stringstream ss;
// ss << line;
// while(ss >> y >> x){
// std::vector<int> pt;
// pt.push_back(x);
// pt.push_back(y);
// points.push_back(pt);
// std::cout << x << " " << y << std::endl;
// LD.lSet(x,y);
// }
// cout << "done..." << endl;
// }
// cout << "here2" << endl;
for( int i=0 ; i<points.size() ; i++ ){
cout << points.size() << endl;
LD.lSet(points[i][0],points[i][1]);
//delayMicroseconds(500);
}
// std::cout << data << std::endl;
// new_sock << data;
}
}
catch ( SocketException& ) {}
}
}
catch ( SocketException& e )
{
std::cout << "Exception was caught:" << e.description() << "\nExiting.\n";
}
return 0;
}
int
#ifdef WIN32_SERVICE
hermes_main
#else
main
#endif //WIN32_SERVICE
(int argc,char *argv[])
{
/* TODO:think of this again
if(argc>2)
{
for(unsigned i=1;i<argc;i++)
{
argv++
}
*/
#ifdef HAVE_SSL
CRYPTO_set_locking_callback(ssl_locking_function);
#ifndef WIN32 //getpid() returns different values for threads on windows, therefor this is not needed
CRYPTO_set_id_callback(pthread_self);
#endif //WIN32
#endif //HAVE_SSL
try
{
if(2==argc)
{
if(!Utils::file_exists(argv[1]))
throw Exception(string(_("Config file "))+argv[1]+_(" doesn't exist or is not readable."),__FILE__,__LINE__);
cfg.parse(argv[1]);
}
else
throw Exception(_("Config file not specified"), __FILE__, __LINE__);
cfg.validateConfig();
}
catch(Exception &e)
{
LERR(e);
return -1;
}
unsigned long nconns=0;
signal(SIGTERM,exit_requested);
signal(SIGINT,exit_requested);
#ifndef WIN32
signal(SIGCHLD,SIG_IGN);
signal(SIGPIPE,SIG_IGN);
#endif //WIN32
//we have to create the server socket BEFORE chrooting, because if we don't,
//SSL cannot initialize because it's missing libz
ServerSocket server;
pthread_t cleaner_thread;
string peer_address;
#ifndef WIN32
if(cfg.getBackground())
{
int retval;
retval=fork();
if(retval>0)
exit(0); //succesful fork
if(retval<0)
{
LERR(_("Error forking into the background") + Utils::errnotostrerror(errno));
return -1;
}
}
if(cfg.getPidFile()!="")
{
try
{
Utils::write_pid(cfg.getPidFile(),getpid());
}
catch(Exception &e)
{
LERR(e);
}
}
if(cfg.getChroot()!="")
{
//this is needed to get hermes to load the dns resolver BEFORE chrooting
(void)gethostbyname("hermes-project.com");
if(-1 == chdir(cfg.getChroot().c_str()))
{
LERR(_("Couldn't chdir into ") + cfg.getChroot() + " " + Utils::errnotostrerror(errno) );
return -1;
}
if(-1==chroot(cfg.getChroot().c_str()))
{
LERR(_("Couldn't chroot ") + Utils::errnotostrerror(errno));
return -1;
}
if(-1 == chdir("/"))
{
LERR(_("Couldn't chdir into /, this shouldn't happen: " + Utils::errnotostrerror(errno)) );
return -1;
}
}
#endif //WIN32
LINF("Starting hermes with pid "+Utils::inttostr(getpid()));
try
{
server.init();
server.setPort(cfg.getListeningPort());
server.listen(cfg.getListeningPort(),cfg.getBindTo());
}
catch(Exception &e)
{
LERR(e);
return -1; //couldn't bind, exit
}
#ifndef WIN32
if(cfg.getDropPrivileges())
{
//drop privileges once we have opened the listening port
if(-1 == setgroups(0,NULL))
{
LERR(_("Error dropping priviledges " + Utils::errnotostrerror(errno)) );
return -1;
}
if(-1 == setgid(cfg.getGid()))
{
LERR(_("Error setting gid " + Utils::inttostr(cfg.getGid()) + " " + Utils::errnotostrerror(errno)) );
return -1;
}
if(-1 == setuid(cfg.getUid()))
{
LERR(_("Error setting uid " + Utils::inttostr(cfg.getUid()) + " " + Utils::errnotostrerror(errno)) );
return -1;
}
if(-1 == setuid(cfg.getUid()))
{
LERR(_("Error setting uid " + Utils::inttostr(cfg.getUid()) + " " + Utils::errnotostrerror(errno)) );
return -1;
}
}
#endif //WIN32
/* start our cleaner thread */
if(cfg.getCleanDb())
pthread_create(&cleaner_thread,NULL,cleaner_thread_run,NULL);
new_conn_info info;
stack<new_conn_info> info_stack;
while(!quit)
{
if(server.canRead(1)) //wait one second for incoming connections, if none then loop again(allows us to check for SIGTERM and SIGINT)
{
pthread_t thread;
pthread_attr_t thread_attr;
pthread_attr_init(&thread_attr);
pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED);
int retval;
int fd=server.accept(&peer_address);
info.new_fd=fd;
info.peer_address=peer_address;
info.connection_id=++nconns;
pthread_mutex_lock(&info_stack_mutex);
info_stack.push(info);
pthread_mutex_unlock(&info_stack_mutex);
retval=pthread_create(&thread,&thread_attr,thread_main,(void *)&info_stack);
if(retval)
{
LERR(_("Error creating thread: ") + Utils::errnotostrerror(retval) + _(". Sleeping 5 seconds before continuing..."));
sleep(5);
}
else
{
#ifdef WIN32
LDEB("New thread created [" + Utils::ulongtostr(nconns) + "] thread_id: " + Utils::ulongtostr((unsigned long)thread.p) + ":" + Utils::ulongtostr(thread.x));
#else
LDEB("New thread created [" + Utils::ulongtostr(nconns) + "] thread_id: " + Utils::ulongtostr(thread));
#endif //WIN32
pthread_mutex_lock(&childrenlist_mutex);
children.push_back(nconns);
pthread_mutex_unlock(&childrenlist_mutex);
}
}
}
//close connection so that the port is no longer usable
server.close();
// wait for all threads to finish
LINF("Waiting for threads to finish");
#ifndef WIN32
while(children.size())
{
if(false==cfg.getBackground())
{
cout << "Threads active:" << children.size() << (char)13;
fflush(stdout);
}
sleep(1);
}
#endif //WIN32
if(cfg.getCleanDb())
pthread_join(cleaner_thread,NULL);
#ifndef WIN32
if(false==cfg.getBackground())
cout << endl;
#endif //WIN32
#ifdef HAVE_SPF
Spf::deinitialize();
#endif //HAVE_SPF
return 0;
}
int main ( int argc, char* argv[] )
{
std::cout << "running....\n";
try
{
// Create the socket
ServerSocket server ( 30000 );
while ( true )
{
ServerSocket varServerSocket;
server.accept ( varServerSocket );
try
{
while ( true )
{
bool varEncrypt (true);
size_t varFound(0);
std::string varScope;
std::string varHash;
std::string varSaltServer;
std::string varSaltClient;
std::string varPassword;
std::string varData;
std::string key;
//Standard ensure the vars are clean
varScope.clear();
varHash.clear();
varSaltClient.clear();
varSaltServer.clear();
varPassword.clear();
varData.clear();
key.clear();
//Standard start buildup
//Sent Salt1 which is used as part of the password hashing
//-e-scope-hash-salt--input
//sha256(salt+password+salt)
//Generate and end the salt
generateRandomString(varSaltServer, 24);
varServerSocket << varSaltServer;
//Get and then process Data
varServerSocket >> varData;
//log(varData);
//Check if encrypting or decrypting
if(varData.substr(0,2) == "-d" ) {
varEncrypt = false;
}
varData.erase (0,int(varFound)+3);
//Check scope (Key set)
varFound = varData.find("-");
if (varFound != std::string::npos) {
varScope = varData.substr (0,int(varFound));
varData.erase (0,int(varFound)+1);
}
//Get Hash and Salt to verify connection
varFound = varData.find("-");
if (varFound != std::string::npos) {
varSaltClient = varData.substr (0,int(varFound));
varData.erase (0,int(varFound)+1);
}
varFound = varData.find("-");
if (varFound != std::string::npos) {
varHash = varData.substr (0,int(varFound));
varData.erase (0,int(varFound));
}
//Find termination string and drop everything before it
varFound = varData.find("--");
if (varFound != std::string::npos) {
varData.erase (0,int(varFound)+2);
}
//Load the configurations for the scope
varPassword = "******";
//Verify the connection
//std::string& varHash, std::string& varSaltServer, std::string& varSaltClient, std::string& varPassword
if(checkHash2Password(varHash, varSaltServer, varSaltClient, varPassword)) {
if(varEncrypt){
//Decrypt
varServerSocket << encrypt(varData);
} else {
//Encrypt
varServerSocket << decrypt(varData);
}
}
//varServerSocket << "Scope: " << varScope << " - Hash: " << varHash << " - Sent: " << varSaltServer << " - Recieved: " << varSaltClient << " - Password: "******"Verification Failed" << "\n\n";
}
}
catch ( SocketException& ) {}
}
}
catch ( SocketException& e )
{
std::cout << "An exception was caught:" << e.description() << "\nExiting.\n";
}
return 0;
}
