/** * Removes a connection from the bandwidth allocator * Requests all other connections update their speed */ int BandwidthAllocator::removeBandwidth(TCPConnection* connection) { boost::unique_lock<boost::mutex> lock(queueMutex); // If we are not in a consistant state - wait while(unsettled.size() > 0 || currentlyWorking) queueWaiting.wait(lock); printf("1\n"); currentlyWorking = true; int removeConnectionFd = connection->getSockFd(); int numConnections = settled.size(); int nodeSpeed = UPLINK_SPEED; if (numConnections != 1) nodeSpeed = UPLINK_SPEED / (numConnections - 1); printf("2\n"); TCPConnection* currentConnection; for (int i = 0; i < numConnections; i++) { currentConnection = settled.front(); settled.pop(); if (currentConnection->getSockFd() != removeConnectionFd) { currentConnection->updateRemoteSpeed(nodeSpeed); unsettled[currentConnection->getSockFd()] = currentConnection; } } printf("3\n"); while(unsettled.size() > 0) queueWaiting.wait(lock); printf("4\n"); currentlyWorking = false; queueWaiting.notify_all(); printf("5\n"); return 0; }
/** * Allocates some bandwidth for the new TCP connection * Notifies all the other connections to change their speed */ int BandwidthAllocator::getBandwidth(TCPConnection* connection) { boost::unique_lock<boost::mutex> lock(queueMutex); while(unsettled.size() > 0 || currentlyWorking) queueWaiting.wait(lock); int numConnections = settled.size(); int nodeSpeed = UPLINK_SPEED / (numConnections + 1); TCPConnection* currentConnection; for (int i = 0; i < numConnections; i++) { currentConnection = settled.front(); settled.pop(); unsettled[currentConnection->getSockFd()] = currentConnection; currentConnection->updateRemoteSpeed(nodeSpeed); } puts("Waiting for unsettled to sort itself out..."); while(unsettled.size() > 0) queueWaiting.wait(lock); settled.push(connection); currentlyWorking = false; queueWaiting.notify_all(); // Return the speed we need to run at // When we update this to handle flows at any time reverse so // we send a bandwidth alloc to the receipent return nodeSpeed; }
bool HTTPServer_Impl::read_lines(TCPConnection &connection, std::string &out_header_lines) { out_header_lines.clear(); while (out_header_lines.length() < 32*1024) { char buffer[1024]; if (connection.get_read_event().wait(15000) == false) throw Exception("Read timed out"); int bytes_read = connection.peek(buffer, 1024); if (bytes_read <= 0) break; std::string str(buffer, bytes_read); std::string::size_type start_pos = out_header_lines.length(); out_header_lines += str; std::string::size_type pos = out_header_lines.find("\r\n\r\n"); if (pos == std::string::npos) { connection.receive(buffer, bytes_read); } else { connection.receive(buffer, pos+4-start_pos); out_header_lines.resize(pos+4); return true; } } return false; }
int main() { TCPConnection* pconnect = new TCPConnection(); pconnect->active_open(); pconnect->active_open(); pconnect->active_open(); pconnect->active_open(); pconnect->active_open(); }
Image Receive::apply(int port) { // create and bind the server if it hasn't already been created if (!servers[port]) { servers[port] = new TCPServer(port); } printf("Listening on port %i\n", port); TCPConnection *conn = servers[port]->listen(); printf("Got a connection, reading image...\n"); Image im = conn->recvImage(); delete conn; return im; }
int main() { //unsigned short port = 8080; TCPConnection *MyConnection = new TCPConnection(); MyConnection->Listen(); MyConnection->Start(); while(1) { this_thread::sleep_for(std::chrono::milliseconds(1)); //sleep(5); } return 0; }
void send_request(TCPConnection &connection) { std::string request = "HEAD /index.html HTTP/1.1\r\n" "Host: www.clanlib.org\r\n" "\r\n"; NetworkConditionVariable wait_condition; std::mutex mutex; std::unique_lock<std::mutex> lock(mutex); size_t pos = 0; while (pos < request.length()) { int bytes_written; while (true) { bytes_written = connection.write(request.data() + pos, request.length() - pos); if (bytes_written != -1) break; NetworkEvent *events[] = { &connection }; wait_condition.wait(lock, 1, events); } pos += bytes_written; } }
void TCPConnection::ThreadListen(void* arg) { //printf("ThreadListe\n"); TCPConnection *MyClass = static_cast<TCPConnection*>(arg); while(MyClass->mRunningListenFlag) { fd_set rfd; // read event fd_set efd; // accept event int retVal, nfds = 0; timeval tv = { 0 }; tv.tv_usec = 1; FD_ZERO(&rfd); FD_ZERO(&efd); FD_SET(MyClass->mSocketListener, &rfd); nfds = nfds > MyClass->mSocketListener ? nfds : MyClass->mSocketListener; FD_SET(MyClass->mSocketListener, &efd); nfds = nfds > MyClass->mSocketListener ? nfds : MyClass->mSocketListener; retVal = select(nfds + 1, &rfd, NULL, & efd, &tv); if (retVal == -1 && errno == EINTR) return ; if (FD_ISSET(MyClass->mSocketListener, &efd)) { char c; retVal = recv(MyClass->mSocketListener, &c, 1, MSG_OOB); } if (FD_ISSET(MyClass->mSocketListener, &rfd)) { //if(MyClass->mSocketPc == -1) MyClass->OnAccept(MyClass->mSocketListener); //else //printf("Reject connection from PC !!!!\n"); } } }
void NetGameServer::listen_thread_main() { while (true) { std::unique_lock<std::mutex> lock(impl->mutex); if (impl->stop_flag) break; NetworkEvent *events[] = { impl->tcp_listen.get() }; impl->worker_event.wait(lock, 1, events); SocketName peer_endpoint; TCPConnection connection = impl->tcp_listen->accept(peer_endpoint); if (!connection.is_null()) { std::unique_ptr<NetGameConnection> game_connection(new NetGameConnection(this, connection)); impl->connections.push_back(game_connection.release()); } } }
DataBuffer receive_response(TCPConnection &connection) { std::array<char, 16000> response_data; NetworkConditionVariable wait_condition; std::mutex mutex; std::unique_lock<std::mutex> lock(mutex); size_t pos = 0; while (pos < response_data.size()) { size_t last_pos = pos > 0 ? pos - 4 : pos; int bytes_read; while (true) { bytes_read = connection.read(response_data.data() + pos, response_data.size() - pos); if (bytes_read != -1) break; NetworkEvent *events[] = { &connection }; wait_condition.wait(lock, 1, events); } pos += bytes_read; if (bytes_read == 0) break; bool end_header_found = false; for (size_t i = last_pos; i + 3 < pos; i++) { if (response_data[i] == '\r' && response_data[i + 1] == '\n' && response_data[i + 2] == '\r' && response_data[i + 3] == '\n') { end_header_found = true; break; } } if (end_header_found) break; } for (auto &line : StringHelp::split_text(std::string(response_data.data(), pos), "\r\n")) { Console::write_line(StringHelp::local8_to_text(line)); } return DataBuffer(); }
void run() { const char* testData = "Twenty-five or six to four"; const size_t testDataLen = strlen(testData); char* buff = reinterpret_cast<char*>(calloc(testDataLen + 1, 1)); const int port = 1337; try { // Create a listener and a client connection TCPListener server(port); TCPConnection client; // Start the server and connect to it server.start(); client.connect(IPEndPoint(IP(127, 0, 0, 1), port)); // Accept the connection auto serverConn = server.accept(); // Test sending from the server to the client serverConn->send(testData, testDataLen); client.receive(buff, testDataLen); if (strcmp(testData, buff) != 0) throw TestFailedException("Data sent from server to client didn't go through properly"); // Reset the buffer and try sending from // the client to the server memset(buff, 0, testDataLen); serverConn->shutDownSending(); client.shutDownReceiving(); client.send(testData, testDataLen); serverConn->receive(buff, testDataLen); if (strcmp(testData, buff) != 0) throw TestFailedException("Data sent from client to server didn't go through properly"); // Shut down the connections client.disconnect(); if (serverConn->receive(buff, testDataLen) != 0) throw TestFailedException("The server was not notified when the client disconnected"); serverConn->disconnect(); free(buff); } catch (...) { free(buff); throw; } }
ThreadReturnType TCPConnection::TCPConnectionLoop(void* tmp) { #ifdef _WINDOWS SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL); #endif if (tmp == 0) { THREAD_RETURN(nullptr); } TCPConnection* tcpc = (TCPConnection*) tmp; #ifndef WIN32 //Log.Out(Logs::Detail, Logs::TCP_Connection, "%s Starting TCPConnectionLoop with thread ID %d", __FUNCTION__, pthread_self()); #endif tcpc->MLoopRunning.lock(); while (tcpc->RunLoop()) { Sleep(LOOP_GRANULARITY); if (!tcpc->ConnectReady()) { if (!tcpc->Process()) { //the processing loop has detecting an error.. //we want to drop the link immediately, so we clear buffers too. tcpc->ClearBuffers(); tcpc->Disconnect(); } Sleep(1); } else if (tcpc->GetAsyncConnect()) { tcpc->SetAsyncConnect(false); } else { Sleep(10); //nothing to do. } } tcpc->MLoopRunning.unlock(); #ifndef WIN32 //Log.Out(Logs::Detail, Logs::TCP_Connection, "%s Ending TCPConnectionLoop with thread ID %d", __FUNCTION__, pthread_self()); #endif THREAD_RETURN(nullptr); }
void run(Thread *thread, void *args) { TCPConnection *conn = static_cast<TCPConnection *>(args); conn->writeData(); }
void HTTPServer_Impl::write_line(TCPConnection &connection, const std::string &line) { connection.send(line.data(), line.length(), true); connection.send("\r\n", 2, true); }
void HTTPServer_Impl::connection_thread_main(TCPConnection connection) { try { std::string request; bool bool_result = read_line(connection, request); if (bool_result == false) { connection.disconnect_abortive(); return; } std::string headers; bool_result = read_lines(connection, headers); if (bool_result == false) { connection.disconnect_abortive(); return; } // Extract request command, url and version: std::string command, url, version; std::string::size_type pos1 = request.find(' '); if (pos1 == std::string::npos) throw Exception("Bad request"); command = request.substr(0, pos1); if (command != "POST" && command != "GET") throw Exception("Unsupported"); std::string::size_type pos2 = request.find(' ', pos1 + 1); if (pos2 == std::string::npos) throw Exception("Bad request"); url = request.substr(pos1+1, pos2-pos1-1); std::string::size_type pos3 = request.find(' ', pos2 + 1); if (pos3 != std::string::npos) throw Exception("Bad request"); version = request.substr(pos2 + 1); DataBuffer request_data; // Handle request: // Look for a request handler that will deal with the HTTP request: MutexSection mutex_lock(&mutex); std::vector<HTTPRequestHandler>::size_type index, size; size = handlers.size(); bool handled = false; for (index = 0; index < size; index++) { if (handlers[index].is_handling_request(command, url, headers)) { HTTPRequestHandler handler = handlers[index]; mutex_lock.unlock(); if (command == "POST") { write_line(connection, "HTTP/1.1 100 Continue"); // write_line(connection, "Content-Length: 0"); write_line(connection, ""); } std::shared_ptr<HTTPServerConnection_Impl> connection_impl(std::make_shared<HTTPServerConnection_Impl>()); connection_impl->connection = connection; connection_impl->request_type = command; connection_impl->request_url = url; connection_impl->request_headers = headers; HTTPServerConnection http_connection(connection_impl); handler.handle_request(http_connection); handled = true; break; } } mutex_lock.unlock(); if (!handled) { // No handler wants it. Reply with 404 Not Found: std::string error_msg("404 Not Found"); write_line(connection, "HTTP/1.1 404 Not Found"); write_line(connection, "Server: ClanLib HTTP Server"); write_line(connection, "Connection: close"); write_line(connection, "Vary: *"); write_line(connection, "Content-Type: text/plain"); write_line(connection, "Content-Length: " + StringHelp::int_to_local8(error_msg.length()+2)); write_line(connection, ""); write_line(connection, error_msg); } connection.disconnect_graceful(); /* if (url == "/") { File file("Sources/test.html", File::open_existing); DataBuffer response(file.get_size()); file.read(response.get_data(), response.get_size(), true); file.close(); // Send back response. write_line(connection, "HTTP/1.1 200 OK"); write_line(connection, "Server: ClanLib HTTP Server"); write_line(connection, "Connection: close"); // write_line(connection, "Date: Sun, 16 Oct 2005 20:13:00 GMT"); // write_line(connection, "Expires: Sun, 16 Oct 2005 20:13:00 GMT"); write_line(connection, "Vary: *"); // write_line(connection, "ETag: \"foobar\""); write_line(connection, "Content-Type: text/html"); write_line(connection, "Content-Length: " + StringHelp::int_to_local8(response.get_size())); write_line(connection, ""); connection.send(response.get_data(), response.get_size(), true); } else { DataBuffer response; bool error = false; try { response = handle_request(url, headers, request_data); } catch (const Exception &e) { // write_line(connection, "HTTP/1.1 404 Not Found"); write_line(connection, "HTTP/1.1 404 Not Found"); write_line(connection, "Server: ClanLib HTTP Server"); write_line(connection, "Connection: close"); // write_line(connection, "Date: Sun, 16 Oct 2005 20:13:00 GMT"); // write_line(connection, "Expires: Sun, 16 Oct 2005 20:13:00 GMT"); write_line(connection, "Vary: *"); // write_line(connection, "ETag: \"foobar\""); write_line(connection, "Content-Type: text/plain"); write_line(connection, "Content-Length: 0"); write_line(connection, ""); error = true; } // Send back response. if (!error) { write_line(connection, "HTTP/1.1 200 OK"); write_line(connection, "Server: ClanLib HTTP Server"); write_line(connection, "Connection: close"); // write_line(connection, "Date: Sun, 16 Oct 2005 20:13:00 GMT"); // write_line(connection, "Expires: Sun, 16 Oct 2005 20:13:00 GMT"); write_line(connection, "Vary: *"); // write_line(connection, "ETag: \"foobar\""); write_line(connection, "Content-Type: text/xml"); write_line(connection, "Content-Length: " + StringHelp::int_to_local8(response.get_size())); write_line(connection, ""); connection.send(response.get_data(), response.get_size(), true); } } */ } catch (const Exception& e) { log_event("error", e.message); } }
int main(int argc, char* argv[]){ gst_init(&argc,&argv); char serverIP[SIZEOFCHARARRAY]; DataBaseAccess *dBA = new DataBaseAccess(); cout<<"\nCreate Main Function DBA\n"; dBA->ClearRtspTable(); if ( CheckValidation( dBA, serverIP ) ){ int channelCount = dBA->IsChannelsExist( dBA->GetSystemDID() ); Notification * notification = new Notification(); Retrieve * RetrieveObj = new Retrieve( serverIP, BroadCastStreamPortNumber, LocalStreamPortNumber ); RetrieveObj->StartThreadForVideoEntry(RetrieveObj); VOD* VODObj = new VOD(serverIP, VODPortNumber ); BootLoader* BootLoaderObj = new BootLoader( RetrieveObj ); BootLoaderObj->StartBoot(); Failover * failover = new Failover(BootLoaderObj); if ( channelCount == 0 ){ failover->StartThread(failover); } else failover->isBreak = true; Interaction * interaction = new Interaction(failover); interaction->InitializeThread(interaction); TCPConnection* TCPConnectionDesktop = new TCPConnection( tcpSocketPortNumber, RetrieveObj, VODObj, notification, false,failover,interaction ); if( !TCPConnectionDesktop->StartInternalThread() ) cout<<"Failed to create thread\n"; TCPConnection* TCPConnectionAndroid = new TCPConnection( AndroidTcpSocketPortNumber, RetrieveObj, VODObj, notification, true,failover,interaction ); if( !TCPConnectionAndroid->StartInternalThread() ) cout<<"Failed to create thread\n"; else cout<<"\nTcp Connection Created\n"; usleep(5); //Monitoring *monitoring = new Monitoring(dBA); #if STARTPROCESSMONITORING cout<<"\nStarting Monitoring\n"; Monitoring *monitoring; monitoring = new Monitoring(); monitoring->StartInternalThread(); #endif dBA->Close(); delete dBA; cout<<"\n Close Main Function DBA\n"; TCPConnectionDesktop->WaitForInternalThreadToExit(); TCPConnectionAndroid->WaitForInternalThreadToExit(); delete VODObj; delete TCPConnectionDesktop; delete TCPConnectionAndroid; delete interaction; delete RetrieveObj; delete failover; delete BootLoaderObj; delete notification; } else{ dBA->Close(); delete dBA; } return 0; }
void TCPCONNECTIONTF::testReadData() { ANET_LOG(DEBUG, "BEGIN testReadData()"); Socket *client = new Socket; client->setAddress("localhost", 12345); client->connect(); Socket *accept = _server->accept(); CPPUNIT_ASSERT(accept); // ConnPacketFactory *factory = new ConnPacketFactory; // DefaultPacketStreamer *streamer = new DefaultPacketStreamer(factory); //tricket 47 TCPConnection *tmpConn = new TCPConnection(accept, _streamer, NULL); DataBuffer buffer; buffer.writeInt32(ANET_PACKET_FLAG + 1); buffer.writeInt32(111); buffer.writeInt32(222); const char *data = "just for test"; buffer.writeInt32(strlen(data) - 1); buffer.writeBytes(data, strlen(data)); ANET_LOG(DEBUG, "buffer(%p) length:(%d)",&buffer, buffer.getDataLen()); client->write(buffer.getData(), buffer.getDataLen()); CPPUNIT_ASSERT(!tmpConn->readData()); buffer.clear(); buffer.writeInt32(ANET_PACKET_FLAG); buffer.writeInt32(111); buffer.writeInt32(222); buffer.writeInt32(-1); buffer.writeBytes(data, strlen(data)); client->write(buffer.getData(), buffer.getDataLen()); CPPUNIT_ASSERT(!tmpConn->readData()); buffer.clear(); buffer.writeInt32(ANET_PACKET_FLAG); buffer.writeInt32(111); buffer.writeInt32(222); buffer.writeInt32(strlen(data)/2); buffer.writeBytes(data, strlen(data)); client->write(buffer.getData(), buffer.getDataLen()); CPPUNIT_ASSERT(!tmpConn->readData()); delete tmpConn; delete accept; client->close(); delete client; // TCPConnection *conn = new TCPConnection(_client, NULL, NULL); _conn->setServer(false); _conn->postPacket(new ConnPacket(11), _handler, NULL); _conn->postPacket(new ConnPacket(21), _handler, NULL); _conn->postPacket(new ConnPacket(31), _handler, NULL); _conn->writeData(); // flag(0x416e457) chid pcode datalen //DataBuffer *input = &_conn->_input; TCPServerAdapter *adapter = new TCPServerAdapter; TCPConnection *connAcc = new TCPConnection(_accept, _streamer, adapter); connAcc->setServer(true); connAcc->_streamer = _streamer; connAcc->_iocomponent = new TCPComponent(_transport, _accept); //connAcc->_streamer, NULL); CPPUNIT_ASSERT(connAcc->readData()); CPPUNIT_ASSERT_EQUAL(3, adapter->handNum); //test error packet adapter->reset(); //set the hand packet num to zero _conn->postPacket(new ConnPacket(20, 11), _handler, NULL); _conn->postPacket(new ConnPacket(20, 30), _handler, NULL); CPPUNIT_ASSERT(_conn->writeData()); CPPUNIT_ASSERT(connAcc->readData()); CPPUNIT_ASSERT_EQUAL(2, adapter->handNum); ANET_LOG(SPAM, "connAcc(%p), ioc (%p)", connAcc, connAcc->_iocomponent); delete connAcc->_iocomponent; delete connAcc; _accept = NULL; delete adapter; ANET_LOG(DEBUG,"END testReadData()"); }
ThreadReturnType TCPConnection::TCPConnectionLoop(void* tmp) { #ifdef _WINDOWS SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL); #endif if (tmp == 0) { THREAD_RETURN(NULL); } TCPConnection* tcpc = (TCPConnection*) tmp; #ifndef WIN32 _log(COMMON__THREADS, "Starting TCPConnectionLoop with thread ID %d", pthread_self()); #endif tcpc->MLoopRunning.lock(); while (tcpc->RunLoop()) { Sleep(LOOP_GRANULARITY); if (!tcpc->ConnectReady()) { _CP(TCPConnectionLoop); if (!tcpc->Process()) { //the processing loop has detecting an error.. //we want to drop the link immediately, so we clear buffers too. tcpc->ClearBuffers(); tcpc->Disconnect(); } Sleep(1); } else if (tcpc->GetAsyncConnect()) { _CP(TCPConnectionLoop); if (tcpc->charAsyncConnect) tcpc->Connect(tcpc->charAsyncConnect, tcpc->GetrPort()); else tcpc->ConnectIP(tcpc->GetrIP(), tcpc->GetrPort()); tcpc->SetAsyncConnect(false); } else Sleep(10); //nothing to do. } tcpc->MLoopRunning.unlock(); #ifndef WIN32 _log(COMMON__THREADS, "Ending TCPConnectionLoop with thread ID %d", pthread_self()); #endif THREAD_RETURN(NULL); }