bool UTPSocket::connectTo(const net::Address& addr) { if (!bt::Globals::instance().isUTPEnabled()) return false; UTPServer & srv = bt::Globals::instance().getUTPServer(); reset(); conn = srv.connectTo(addr); Connection::Ptr ptr = conn.toStrongRef(); if (!ptr) return false; m_state = CONNECTING; ptr->setBlocking(blocking); if (blocking) { bool ret = ptr->waitUntilConnected(); if (ret) m_state = CONNECTED; return ret; } return ptr->connectionState() == CS_CONNECTED; }
bool UTPSocket::ready(const net::Poll* p, net::Poll::Mode mode) const { Q_UNUSED(p); Connection::Ptr ptr = conn.toStrongRef(); if (!ptr) return false; if (mode == net::Poll::OUTPUT) { if (polled_for_writing) { polled_for_writing = false; return ptr->isWriteable(); } } else { if (polled_for_reading) { polled_for_reading = false; return bytesAvailable() > 0 || ptr->connectionState() == CS_CLOSED; } } return false; }
void UTPSocket::setBlocking(bool on) { blocking = on; Connection::Ptr ptr = conn.toStrongRef(); if (ptr) ptr->setBlocking(on); }
bt::Uint32 UTPSocket::bytesAvailable() const { Connection::Ptr ptr = conn.toStrongRef(); if (ptr) return ptr->bytesAvailable(); else return 0; }
void UTPServer::Private::reset(const utp::Header* hdr) { Connection::Ptr c = find(hdr->connection_id); if (c) { c->reset(); } }
int RaftConsensus::onSendAppendEntries(Node& node, msg_appendentries_t& data) { Connection::Ptr pConnection = findOrCreateConnection(node); if (pConnection) { return pConnection->onSendAppendEntries(data); } return -1; }
void Network::addConnection(Connection::Ptr conn) { DEBUG("Adding a file descriptor %d", conn->getFD()); connections[conn->getFD()] = conn; FD_SET(conn->getFD(), &master_set); if (max_fd < conn->getFD()) { max_fd = conn->getFD(); } }
int RaftConsensus::onSendRequestVote(Node& node, msg_requestvote_t& data) { Connection::Ptr pConnection = findOrCreateConnection(node); if (pConnection) { return pConnection->onSendRequestVote(data); } return -1; }
void RaftConsensus::removeConnection(int id) { Connection::Ptr pConnection; pConnection = findConnection(id); if (!pConnection) { pConnection->shutdown(); OSS::mutex_critic_sec_lock lock(_connectionMutex); _connections.erase(id); } }
int RaftConsensus::onReceivedRequestVote(const Connection::Ptr& pConnection, msg_requestvote_t& data) { OSS::mutex_lock lock(_raftMutex); int ret = 0; msg_requestvote_response_t response; ret = raft_recv_requestvote(_raft, pConnection->getNode().node(), &data, &response); if (ret != 0) { return ret; } return pConnection->onSendRequestVoteResponse(response); }
bool UTPSocket::connectSuccesFull() { Connection::Ptr ptr = conn.toStrongRef(); if (ptr && ptr->connectionState() == CS_CONNECTED) { setRemoteAddress(ptr->remoteAddress()); m_state = CONNECTED; return true; } else return false; }
int RaftConsensus::onReceivedAppendEntries(const Connection::Ptr& pConnection, msg_appendentries_t& data) { OSS::mutex_lock lock(_raftMutex); int ret = 0; msg_appendentries_response_t response; ret = raft_recv_appendentries(_raft, pConnection->getNode().node(), &data, &response); if (ret != 0) { return ret; } return pConnection->onSendAppendEntriesResponse(response); }
const net::Address& UTPSocket::getPeerName() const { Connection::Ptr ptr = conn.toStrongRef(); if (remote_addr_override) return addr; else if (ptr) return ptr->remoteAddress(); else { static net::Address null; return null; } }
void UTPSocket::prepare(net::Poll* p, net::Poll::Mode mode) { Connection::Ptr ptr = conn.toStrongRef(); if (ptr && ptr->connectionState() != CS_CLOSED) { UTPServer & srv = bt::Globals::instance().getUTPServer(); srv.preparePolling(p, mode, ptr); if (mode == net::Poll::OUTPUT) polled_for_writing = true; else polled_for_reading = true; } }
UTPSocket::UTPSocket(Connection::WPtr conn) : net::SocketDevice(bt::UTP), conn(conn), blocking(true), polled_for_reading(false), polled_for_writing(false) { Connection::Ptr ptr = conn.toStrongRef(); if (ptr) { setRemoteAddress(ptr->remoteAddress()); ptr->setBlocking(blocking); m_state = CONNECTED; } }
void UTPSocket::close() { Connection::Ptr ptr = conn.toStrongRef(); if (ptr) { try { ptr->close(); } catch (Connection::TransmissionError) { reset(); } } }
bool handleFrame(Connection::Ptr pConnection, Frame::Ptr pFrame) { if (pFrame->type() == Frame::FRAME_TYPE_EVSU || pFrame->type() == Frame::FRAME_TYPE_EVUN) { Poco::RemotingNG::ORB& orb = Poco::RemotingNG::ORB::instance(); std::string suri(pFrame->payloadBegin(), pFrame->getPayloadSize()); Poco::URI dispURI(suri); dispURI.setAuthority(_pListener->endPoint()); dispURI.setFragment(""); Poco::RemotingNG::EventDispatcher::Ptr pEventDispatcher = orb.findEventDispatcher(dispURI.toString(), Transport::PROTOCOL); if (pFrame->type() == Frame::FRAME_TYPE_EVSU) { Poco::Timestamp expire; expire += _pListener->getEventSubscriptionTimeout().totalMicroseconds(); pEventDispatcher->subscribe(suri, suri, expire); } else { pEventDispatcher->unsubscribe(suri); } pConnection->returnFrame(pFrame); return true; } return false; }
int UTPSocket::send(const bt::Uint8* buf, int len) { Connection::Ptr ptr = conn.toStrongRef(); if (!ptr) return -1; try { return ptr->send(buf, len); } catch (Connection::TransmissionError & err) { close(); return -1; } }
void Server::sendStateToConnection(Connection::Ptr const& connection) { BOOST_FOREACH(Connection::Ptr const& conn, connectionPool_) { connection->send(Message<MessageType::updateReadiness>( {conn->id(), conn->ready()} )); }
void ServerConnection::run() { if (_logger.debug()) _logger.debug("ServerConnection started."); Connection::Ptr pConnection = new Connection(socket(), Connection::MODE_SERVER); EventSubscriptionFrameHandler::Ptr pEventSubFrameHandler = new EventSubscriptionFrameHandler(_pListener); RequestFrameHandler::Ptr pRequestFrameHandler = new RequestFrameHandler(_pListener); pConnection->pushFrameHandler(pEventSubFrameHandler); pConnection->pushFrameHandler(pRequestFrameHandler); _pListener->connectionManager().registerConnection(pConnection); try { _pListener->connectionAccepted(pConnection); } catch (Poco::Exception& exc) { _logger.error("connectionAccepted event handler threw exception: " + exc.displayText()); } catch (...) { _logger.error("connectionAccepted event handler threw unknown exception"); } try { pConnection->run(); } catch (Poco::Exception& exc) { _logger.log(exc); } _pListener->connectionManager().unregisterConnection(pConnection); pConnection->popFrameHandler(pRequestFrameHandler); pConnection->popFrameHandler(pEventSubFrameHandler); if (_logger.debug()) _logger.debug("ServerConnection done."); }
int UTPSocket::recv(bt::Uint8* buf, int max_len) { Connection::Ptr ptr = conn.toStrongRef(); if (!ptr || ptr->connectionState() == CS_CLOSED) return 0; try { if (ptr->bytesAvailable() == 0) { if (blocking) { if (ptr->waitForData()) return ptr->recv(buf, max_len); else return 0; // connection should be closed now } else return -1; // No data ready and not blocking so return -1 } else return ptr->recv(buf, max_len); } catch (Connection::TransmissionError & err) { close(); return -1; } }
void accept() { auto self = shared_from_this(); awaitingConnection = std::make_shared<Connection>(io); acceptor.async_accept(awaitingConnection->stream1(), [this, self] (const error_code &error) { if (error) { std::cerr << "accept: " << error << std::endl; } else { Connection::Ptr thisConnecion; std::swap(thisConnecion, awaitingConnection); accept(); error_code localSocketError; thisConnecion->stream2().connect(socketPath, localSocketError); if (localSocketError) { std::cerr << "connecting local socket: " << localSocketError << std::endl; thisConnecion->stream1().close(localSocketError); return; } thisConnecion->start(); } }); }
void Network::masterLoop() { struct timeval tv; fd_set cur_set; halt = false; while (!halt) { //sleep(1); bool netstat = active; while(!timers.empty() && (timers.top()->getExpireTime() <= static_cast<uint64_t>(time(NULL)) || !(timers.top()->isValid()))){ TimerCallback::Ptr callback = timers.top(); timers.pop(); if(callback->isValid()) callback->call(); } if(timers.empty()){ tv.tv_sec = 60; tv.tv_usec = 0; }else{ tv.tv_sec = (timers.top()->getExpireTime() - time(NULL)) - 1; if(tv.tv_sec <= 0){ tv.tv_sec = 0; tv.tv_usec = 200000; }else{ tv.tv_usec = 0; } } fd_set write_set; FD_ZERO(&write_set); // Unsure what the macro FD_SET stands for, so I can't do for_each for(ConnMap::iterator itcurr = writequeue.begin(); itcurr != writequeue.end(); ++itcurr){ FD_SET(itcurr->first, &write_set); } cur_set = master_set; if (select(max_fd + 1, &cur_set, &write_set, NULL, &tv) > 0) { for(ConnMap::iterator itcurr = writequeue.begin(); itcurr != writequeue.end(); ++itcurr){ if(FD_ISSET(itcurr->first, &write_set)){ Connection::Ptr conn = itcurr->second; writequeue.erase(itcurr); conn->processWrite(); //use select again, don't check rest of list as it has changed. break; } } ConnMap::iterator itcurr; for (itcurr = connections.begin(); itcurr != connections.end(); itcurr++) { Connection::Ptr connection = itcurr->second; if (FD_ISSET(itcurr->first, &cur_set)) { connection->process(); } if (connection->getStatus() == Connection::DISCONNECTED) { INFO("Closed connection %d", connection->getFD()); removeConnection(itcurr->first); //use select again, don't check rest of list as it has changed. break; } } } //advertiser->poll(); if(netstat != active && active == false){ for_each_key( connections.begin(), connections.end(), boost::bind( &Network::removeConnection, this, _1 ) ); DEBUG("Network really stopped"); } } }
void Network::addToWriteQueue(Connection::Ptr conn){ writequeue[conn->getFD()] = conn; }
int main() { // Create our TCP listener socket. auto listener = sfn::TcpListener::Create(); // Listen on 0.0.0.0:443 listener->Listen( sfn::Endpoint{ sfn::IpAddress{ "0.0.0.0" }, 443 } ); // Start 3 network processing threads. sfn::Start( 3 ); // Just to make our lives easier... typedef sfn::TlsConnection<sfn::TcpSocket, sfn::TlsEndpointType::Server, sfn::TlsVerificationType::None> Connection; // A place to store all active connections. std::deque<Connection::Ptr> connections; const std::string certificate_string = "-----BEGIN CERTIFICATE-----\r\n" "MIIDPjCCAiagAwIBAgIBAjANBgkqhkiG9w0BAQUFADBFMQswCQYDVQQGEwJGUjEO\r\n" "MAwGA1UEBxMFUGFyaXMxDjAMBgNVBAoTBVh5U1NMMRYwFAYDVQQDEw1YeVNTTCBU\r\n" "ZXN0IENBMB4XDTA3MDcwNzA1MDEyOVoXDTA4MDcwNjA1MDEyOVowMTELMAkGA1UE\r\n" "BhMCRlIxDjAMBgNVBAoTBVh5U1NMMRIwEAYDVQQDEwlsb2NhbGhvc3QwggEiMA0G\r\n" "CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC40PDcGTgmHkt6noXDfkjVuymjiNYB\r\n" "gjtiL7uA1Ke3tXStacEecQek/OJxYqYr7ffcWalS29LL6HbKpi0xLZKBbD9ACkDh\r\n" "1Z/SvHlyQPILJdYb9DMw+kzZds5myXUjzn7Aem1YjoxMZUAMyc34i2900X2pL0v2\r\n" "SfCeJ9Ym4MOnZxYl217+dX9ZbkgIgrT6uY2IYK4boDwxbTcyT8i/NPsVsiMwtWPM\r\n" "rnQMr+XbgS98sUzcZE70Pe1TlV9Iy8j/8d2OiFo+qTyMu/6UpM2s3gdkQkMzx+Sm\r\n" "4QitRUjzmEXeUePRUjEgHIv7vz069xuVBzrks36w5BXiVAhLke/OTKVPAgMBAAGj\r\n" "TTBLMAkGA1UdEwQCMAAwHQYDVR0OBBYEFNkOyCTx64SDdPySGWl/tzD7/WMSMB8G\r\n" "A1UdIwQYMBaAFLzuH5jo+iuD5KR9XsN1cpMx2TJnMA0GCSqGSIb3DQEBBQUAA4IB\r\n" "AQBelJv5t+suaqy5Lo5bjNeHjNZfgg8EigDQ7NqaosvlQZAsh2N34Gg5YdkGyVdg\r\n" "s32I/K5aaywyUbG9qVXQxCM2T95qBqyK56h9yJoZKWQD9H//+zB8kCK/16WvRfv3\r\n" "VA7eSR19qOFWlHe+1qGh2YhxeDUfyi+fm4D36dGxqC2A34tZjo0QPHKtIeqM0kJy\r\n" "zzL65TlbJQKkyTuRHofFv0jW9ZFG2wkGysVgCY5fjuLI1do/sWUaXd2987iNFa+K\r\n" "FrHsTi6urSfZuGlZNxDXDHEE7Q2snAvvev+KR7DD9X4DJGcPX9gA4CGJj+9ZzyAA\r\n" "ZTGpOzk1hIH44RFs2lJMZRlE\r\n" "-----END CERTIFICATE-----\r\n"; const std::string key_string = "-----BEGIN PRIVATE KEY-----\r\n" "MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC40PDcGTgmHkt6\r\n" "noXDfkjVuymjiNYBgjtiL7uA1Ke3tXStacEecQek/OJxYqYr7ffcWalS29LL6HbK\r\n" "pi0xLZKBbD9ACkDh1Z/SvHlyQPILJdYb9DMw+kzZds5myXUjzn7Aem1YjoxMZUAM\r\n" "yc34i2900X2pL0v2SfCeJ9Ym4MOnZxYl217+dX9ZbkgIgrT6uY2IYK4boDwxbTcy\r\n" "T8i/NPsVsiMwtWPMrnQMr+XbgS98sUzcZE70Pe1TlV9Iy8j/8d2OiFo+qTyMu/6U\r\n" "pM2s3gdkQkMzx+Sm4QitRUjzmEXeUePRUjEgHIv7vz069xuVBzrks36w5BXiVAhL\r\n" "ke/OTKVPAgMBAAECggEAF5qHyHRoGWYxGZ35U3hjcPiQXtRxEIxDbUzPU6rVKL9C\r\n" "AYvKIEsrQMUTXovM0Tt5Nmk1GOH+UBCGa2dBylAZr/HVOiaVFsKjwNRVZmQpBYd1\r\n" "iuhrSUwOWI+12KbOER6kTYzVPkQmYvNjdL6pUZ7tQywmMl9aAkB7PJe14A1Ar7Zh\r\n" "K34KM8iogdyHUp7FSe903377WgTHoBu5nxPhq+EVhlA/Xm1k0ayTYt9CVhL819uj\r\n" "CQKx3T9NW5skGYMZQwv8TkxvGPEvOVo0HYxXn1wE2CyADfkI4MBQXjE7KhJ9kaob\r\n" "VFv2pCu/UTonPnp0bxKwoXceqcOPGI85UE0UGdUn4QKBgQDb0yECwoybheoFQqnq\r\n" "kgwVOCb+zUTm/GKDvS+oiIv6C68GGFDvOzXxQxM1dmgwQs2gH96/183QKNzVWvjp\r\n" "v/H/IPDvAxv3qL6/MQ07O7hEdaLc5akI9umoEoSLeHM3wz4G6U9fwINDHdotGt/H\r\n" "DnUnkS4DQ17JueBsi2DFOLS7qQKBgQDXOvTo/lh06Fge1JYOWR4Pj0wClxW7Noee\r\n" "wdlUCFSq7dHCLL0tFoktl+vt9ANv0NgltmmzFNEsbotIByxHubD6b4a82oa3/2lK\r\n" "pu1b4v9XBVZLIX5hiSXFlQPdQADKsNVwMQJrlL6Np3gKyL+VUe3m6VYhyRYvV8m9\r\n" "p2fm5so0NwKBgD7vXFUY8/6WwWBOLK1+sLzmfauXgzGKcn37DQj4RvMIo0xga9OC\r\n" "JTh0lqxIwR2IEqzUUwajt0XwXQEscXUiwhrkCHa1ci1ef3Xnij06JNBcyYrqqZFq\r\n" "d4zp+E6h5oLBgCGkbFgimrH9evhM6GJqDjqMwxqmEB46/Di3UrZEPOI5AoGBALI8\r\n" "IJTSDG7D+jWN1rYLFtnL0SZT96sRfT37Sf5M59ClIQ+r/P1ZrEAVj0t+x1nRmS2h\r\n" "4eZrVs10veLoDcNYAzdhJDNAxE+bM5aepfFyCgIGaW/OTNp4uM7mmEygtAcmaZp+\r\n" "+4Ibq7Gi/cXweLcvIdQXZzyTScvq5yYne+O7O7gBAoGAFIBIwAlLrcz1QkHURrPL\r\n" "a/Y1bDTgKbM3FR9ase4ql38LaKThAq7SxE6v0qeQODHESGMObuVeGVbXY9TjbI5G\r\n" "y3kjcRprUJ+Lgo8Wf+jO36I0FivN3xPK+duqR0QKXT4bYWj8RHg1EK/trbhY0Sw4\r\n" "wbMZGrDlydImuNtktgxojIo=\r\n" "-----END PRIVATE KEY-----\r\n"; // Load the certificate and key auto certificate = sfn::TlsCertificate::Create( certificate_string ); auto key = sfn::TlsKey::Create( key_string ); std::atomic_bool exit{ false }; std::cout << "Press ENTER to exit.\n"; // Don't use sfn::Thread for your own projects, it is not what you think it is. sfn::Thread exit_handler( [&]() { std::cin.get(); exit = true; } ); while( !exit ) { { Connection::Ptr connection; // Dequeue any connections from the listener. while( ( connection = listener->GetPendingConnection<Connection>() ) ) { // Set the server certificate and key pair. connection->SetCertificateKeyPair( certificate, key ); // Turn of connection lingering. connection->SetLinger( 0 ); char response[] = "HTTP/1.1 200 OK\r\n" "Server: SFNUL HTTPS Server\r\n" "Content-Type: text/html; charset=UTF-8\r\n" "Connection: close\r\n\r\n" "<html><head><title>SFNUL HTTPS Server Page</title></head>" "<body>SFNUL HTTPS Server Document</body></html>\r\n\r\n"; // Send the HTTP response. connection->Send( response, sizeof( response ) - 1 ); // Shutdown the connection for sending. connection->Shutdown(); // Store the connection. connections.push_back( connection ); } } for( auto connection_iter = connections.begin(); connection_iter != connections.end(); ) { // Remove and thereby close all active connections that have been // remotely shut down and don't have data left to send. if( ( *connection_iter )->RemoteHasShutdown() && !( *connection_iter )->BytesToSend() ) { //( *connection_iter )->Shutdown(); connection_iter = connections.erase( connection_iter ); } else { ++connection_iter; } } } // Close the listener socket. listener->Close(); // Stop all network processing threads. sfn::Stop(); return 0; }
int RaftConsensus::onReceivedAppendEntriesResponse(const Connection::Ptr& pConnection, msg_appendentries_response_t& data) { OSS::mutex_lock lock(_raftMutex); return raft_recv_appendentries_response(_raft, pConnection->getNode().node(), &data); }
int RaftConsensus::onReceivedRequestVoteResponse(const Connection::Ptr& pConnection, msg_requestvote_response_t& data) { OSS::mutex_lock lock(_raftMutex); return raft_recv_requestvote_response(_raft, pConnection->getNode().node(), &data); }
bool UTPSocket::ok() const { Connection::Ptr ptr = conn.toStrongRef(); return ptr && ptr->connectionState() != CS_CLOSED; }
void TargetReady::SetConnection(Connection::Ptr conn) { assert(conn_set_.find(conn) == conn_set_.end()); conn_set_.insert(conn); conn->BindDelegate(this); }