C++ ServerSocket::accept方法代码示例

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);
	}
}

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;
}