Example #1
0
 void Client::request(
     Method method, Uri uri,
     Header header,
     void *data, int len){
     
     TCPSocket *socket = new TCPSocket(
         uri.getDomain().c_str(), uri.getPort(),
         [=](int err, TCPSocket *socket){
             if( err != eNoError ){
                 EP_SAFE_DEFER( responseCallback, err, Header(),"" );
             }
             else{
                 string *buffer = new string();
                 
                 socket->onReceive(
                     [=](void *data, int len){
                         buffer->append( (char*)data );
                     });
                 socket->onUnbind(
                     [=](){
                         Header header;
                         string body;
                         int offset = header.load( *buffer );
                         
                         /*
                          todo : parse chunked content-length
                          */
                         header.getField(
                             "Transfer-Encoding");
                         
                         if( offset == - 1 ){
                             EP_SAFE_DEFER( responseCallback, eParseError, Header(),"" );
                         }
                         else{
                             body = buffer->substr( offset );
                             
                             EP_SAFE_DEFER( responseCallback, eNoError, header, body );
                         }
                         
                         delete buffer;
                     });
                 
                 string requestLine =
                     generateRequestLine( method, uri.getRequestUri(), "HTTP/1.1" );
                 string headerString =
                     header.dump();
                 
                 socket->write(
                     (void*)requestLine.c_str(), requestLine.size());
                 socket->write(
                     (void*)headerString.c_str(), headerString.size());
                 
                 if( len > 0 ){
                     socket->write( data, len );
                 }
             }
         });
 }
bool TcpSocketTest::test(){
	start();
	sleep(1);
	TCPSocket* client = new TCPSocket("127.0.0.1",9586);
	string msg = "12345678901234567890";
	client->write(msg.c_str(), msg.length());
	cout<<"client sent: "<<msg<<endl;
	char buff[1024];
	ssize_t rc = client->read(buff,sizeof(buff));
	buff[rc] = '\0';
	cout<<"client recv: "<<buff<<endl;

	client->close();
	delete client;


	if(rc == (int)msg.size()){
		if(strcmp(msg.c_str(),buff) == 0){
			return true;
		}
	}
	cerr<<"TCP test failed"<<endl;
	waitForThread();
	return false;
}
Example #3
0
void runClient(const char * host, int port, const char * message)
{
  printf("Setting up a client socket to %s:%d\n", host, port);

  TCPSocket socket;
  int err = socket.open(host, port);

  if(err) {
    const int  msgSize = 128;
    char  msgBuf[msgSize] = "";
    printf("%s cannot open client socket to %s:%d -> %s\n", 
	   appname, host, port, strerror_s(msgBuf, msgSize, err));
    return;
  }

  socket.setNoDelay(true);

  char buf[1024];

  for(int i = 0; i < iterations; i++) {

    puts("Sending message");

    sprintf(buf, "%s %d", message, i + 1);
    
    int32_t len = strlen(buf) + 1;
    socket.write( & len, 4);
    socket.write(buf, len);

    if(withreplies) {
      len = 0;
      socket.read( & len, 4);
      bzero(buf, sizeof(buf));
      socket.read(buf, len);
      printf("Received reply \"%s\"\n", buf);
    }
  }

  puts("Closing");

  socket.close();
}
void TcpSocketTest::run(){
	TCPSocket* server = new TCPSocket(9586);
	TCPSocket* peer = server->listenAndAccept();
	cout<<"server got peer connection"<<endl;

	char buff[1024];
	int rc = peer->read(buff,sizeof(buff));

	buff[rc] = '\0';
	cout<<"server recv: "<<buff<<endl;

	peer->write(buff, strlen(buff));
	cout<<"server sent: "<<buff<<endl;

	peer->close();
	server->close();
	delete peer;
	delete server;
}
Example #5
0
void runServer(const char * host, int port, bool withBlocking)
{
  printf("Setting up a server socket to %s:%d\n", host, port);

  char buf[1024];

  TCPServerSocket server;
  int i, err = server.open(host, port, 5);
// err = server.open(0, port, 5)
  if(err) {
    const int  msgSize = 128;
    char  msgBuf[msgSize] = "";
    printf("%s cannot open server socket to %s:%d -> %s\n", 
	   appname, host, port, strerror_s(msgBuf, msgSize, err));
    return;
  }
  
  for(i = 0; i < 10; i++) {
    puts("Waiting for a connection");

    while(withBlocking && !server.isPendingConnection(1000000)) {
      printf(".");
      fflush(0);
    }

    TCPSocket * socket = server.accept();

    if(!socket) {
      Radiant::error("Could not create accept a socket connection.");
      return;
    }

    socket->setNoDelay(true);

    printf("Got a new socket %p\n", socket);
    fflush(0);

    for(int j = 0; j < iterations; j++) {
      int32_t len = 0;
      buf[0] = '\0';
      int n = socket->read( & len, 4);
      
      if(n != 4) {
	Radiant::error("Could not read 4 header bytes from the socket, got %d", n);
	delete socket;
	return;
      }
      
      n = socket->read(buf, len);
      
      if(n != len) {
	Radiant::error("Could not read %d data bytes from the socket, got %d",
		       len, n);
      }
      
      printf("Received \"%s\"\n", buf);

      if(withreplies) {
	socket->write( & len, 4);
	socket->write( & buf, len);
      }
    }

    delete socket;
  }
  
  fflush(0);

  info("%s %d clients handled, returning", appname, i);
}
Example #6
0
//-----------------------------------------------------------------------------
void ConsoleServer::send(TCPSocket client, const char* message)
{
	uint32_t msg_len = string::strlen(message);
	client.write((const char*) &msg_len, 4);
	client.write(message, msg_len);
}