void justine::sampleclient::ShmClient::route2 ( boost::asio::ip::tcp::socket & socket, int id ) { boost::system::error_code err; size_t length = std::sprintf ( data, "<route 6 %d 1348670117 320900594 1348670109 320900801 651365957 2969934868>", id ); socket.send ( boost::asio::buffer ( data, length ) ); length = socket.read_some ( boost::asio::buffer ( data ), err ); if ( err == boost::asio::error::eof ) { // TODO } else if ( err ) { throw boost::system::system_error ( err ); } std::cout.write ( data, length ); std::cout << "Command ROUTE2 sent." << std::endl; }
void on_connect(boost::asio::ip::tcp::socket &socket) { SNOW_LOG_TRACE("new Connection socket fd {}, local addr {}, peer addr {}", socket.native(), socket.local_endpoint(), socket.remote_endpoint()); std::make_shared<Connection>(socket, m_request_dispatcher, m_pkg_spliter, 100 * 1000)->start(); }
int justine::sampleclient::ShmClient::init ( boost::asio::ip::tcp::socket & socket ) { boost::system::error_code err; size_t length = std::sprintf ( data, "<init guided Binfavágók 1 c>" ); socket.send ( boost::asio::buffer ( data, length ) ); length = socket.read_some ( boost::asio::buffer ( data ), err ); if ( err == boost::asio::error::eof ) { // TODO } else if ( err ) { throw boost::system::system_error ( err ); } int id {0}; std::sscanf ( data, "<OK %d", &id ); std::cout.write ( data, length ); std::cout << "Command INIT sent." << std::endl; return id; }
void justine::sampleclient::ShmClient::gangsters ( boost::asio::ip::tcp::socket & socket, int id ) { boost::system::error_code err; size_t length = std::sprintf ( data, "<gangsters " ); length += std::sprintf ( data+length, "%d>", id ); socket.send ( boost::asio::buffer ( data, length ) ); length = socket.read_some ( boost::asio::buffer ( data ), err ); if ( err == boost::asio::error::eof ) { // TODO } else if ( err ) { throw boost::system::system_error ( err ); } std::cout.write ( data, length ); std::cout << "Command GANGSTER sent." << std::endl; }
void send() { BOOST_CHECK_EQUAL( socket_.is_open(), true ); size_t l = 5; socket_.send( boost::asio::buffer( &l, sizeof(size_t) ) ); socket_.send( boost::asio::buffer( "hello", 5 ) ); }
//=========================================================================== void CHttpClient::DoConnect ( const boost::system::error_code & err, boost::asio::ip::tcp::resolver::iterator iter ) { if (err) { if (iter != boost::asio::ip::tcp::resolver::iterator()) { m_socket.close(); boost::asio::ip::tcp::endpoint endPoint = *iter; auto handler = boost::bind( &CHttpClient::DoConnect, this, boost::asio::placeholders::error, ++iter ); m_socket.async_connect(endPoint, handler); } else { printf("%s\n", __FUNCTION__); cout<<"Error: "<<err.message()<<endl; } return; } auto handler = boost::bind( &CHttpClient::DoWriteRequest, this, boost::asio::placeholders::error ); boost::asio::async_write(m_socket, m_request, handler); }
void justine::sampleclient::ShmClient::car ( boost::asio::ip::tcp::socket & socket, int id, unsigned *f, unsigned *t, unsigned* s ) { boost::system::error_code err; size_t length = std::sprintf ( data, "<car " ); length += std::sprintf ( data+length, "%d>", id ); socket.send ( boost::asio::buffer ( data, length ) ); length = socket.read_some ( boost::asio::buffer ( data ), err ); if ( err == boost::asio::error::eof ) { // TODO } else if ( err ) { throw boost::system::system_error ( err ); } int idd {0}; std::sscanf ( data, "<OK %d %u %u %u", &idd, f, t, s ); std::cout.write ( data, length ); std::cout << "Command CAR sent." << std::endl; }
/** Check that local endpoint is loopback * * @throws Face::Error if validation failed */ static void validateSocket(boost::asio::ip::tcp::socket& socket) { if (!socket.local_endpoint().address().is_loopback() || !socket.remote_endpoint().address().is_loopback()) { throw Face::Error("TcpLocalFace can be created only on loopback interface"); } }
std::vector<justine::sampleclient::MyShmClient::Gangster> justine::sampleclient::MyShmClient::gangsters ( boost::asio::ip::tcp::socket & socket, int id, osmium::unsigned_object_id_type cop ) { boost::system::error_code err; size_t length = std::sprintf ( data, "<gangsters " ); length += std::sprintf ( data+length, "%d>", id ); socket.send ( boost::asio::buffer ( data, length ) ); length = socket.read_some ( boost::asio::buffer ( data ), err ); if ( err == boost::asio::error::eof ) { // TODO } else if ( err ) { throw boost::system::system_error ( err ); } /* reading all gangsters into a vector */ int idd {0}; unsigned f, t, s; int n {0}; int nn {0}; std::vector<Gangster> gangsters; while ( std::sscanf ( data+nn, "<OK %d %u %u %u>%n", &idd, &f, &t, &s, &n ) == 4 ) { nn += n; gangsters.push_back ( Gangster {idd, f, t, s} ); } std::sort ( gangsters.begin(), gangsters.end(), [this, cop] ( Gangster x, Gangster y ) { return dst ( cop, x.to ) < dst ( cop, y.to ); } ); std::cout.write ( data, length ); std::cout << "Command GANGSTER sent." << std::endl; return gangsters; }
inline connection::~connection() { socket_m.close(); read_thread_m.join(); send_thread_m.join(); }
void server::handle_request(boost::asio::ip::tcp::socket& socket, const request& req, reply& rep) { using namespace boost::posix_time; detail::s_log.reset(new ostringstream); ptime start = second_clock::local_time(); try { handle_request(req, rep); } catch (...) { rep = reply::stock_reply(internal_server_error); } // protect the output stream from garbled log messages boost::mutex::scoped_lock lock(detail::s_log_lock); cout << socket.remote_endpoint().address() << " [" << start << "] " << second_clock::local_time() - start << ' ' << rep.status << ' ' << detail::s_log->str() << endl; }
void handler::async_read() { auto self(shared_from_this()); m_socket.async_read_some(boost::asio::buffer(m_buffer), std::bind(&handler::handle_read, self, std::placeholders::_1, std::placeholders::_2)); }
bool TcpProxyServer::GetRemoteAddressAndPort(boost::asio::ip::tcp::socket& clientSocket, boost::asio::ip::address& remoteAddress, unsigned short& remotePort) { boost::asio::ip::tcp::socket::endpoint_type userAgentEnpoint = clientSocket.remote_endpoint(); unsigned short userAgentPort = userAgentEnpoint.port(); boost::asio::ip::address userAgentIP = userAgentEnpoint.address(); if(userAgentIP != boost::asio::ip::address_v4::from_string("127.0.0.1")) { return false; } std::pair<u_long, USHORT> remoteAddressPair = WinsockHooker::GetRemoteAddressPair(userAgentPort); if(remoteAddressPair.first == 0ul) { return false; } boost::asio::ip::address_v4 remote_address(remoteAddressPair.first); unsigned short remote_port = remoteAddressPair.second; if(remote_address == boost::asio::ip::address_v4::from_string("127.0.0.1") && remote_port == listen_port) { return false; } remoteAddress = remote_address; remotePort = remote_port; TSINFO4CXX("Connect: IP:" << remoteAddress.to_string() << ", Port: " << remotePort); return true; }
void start() { socket_.async_read_some(boost::asio::buffer(data_), boost::bind(&session::handle_read, shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred)); }
static void connected(const boost::system::error_code & ec, boost::asio::ip::tcp::socket & msocket) { if ( ec ) std::cout << ec.message() << std::endl; else msocket.write_some(boost::asio::buffer(std::string("GET / HTTP/1.1\r\n\r\n"))); }
~WSClientImpl() override { ws_.close({}); stream_.close(); work_ = boost::none; thread_.join(); }
bool CPanasonicNode::handleConnect(boost::asio::ip::tcp::socket& socket, boost::asio::ip::tcp::endpoint endpoint, boost::system::error_code& ec) { try { if (!m_stoprequested) { socket.connect(endpoint, ec); if (!ec) { if (DEBUG_LOGGING) _log.Log(LOG_NORM, "Panasonic Plugin: (%s) Connected to '%s:%s'.", m_Name.c_str(), m_IP.c_str(), (m_Port[0] != '-' ? m_Port.c_str() : m_Port.substr(1).c_str())); return true; } else { if (DEBUG_LOGGING) if (((ec.value() != 113) && (ec.value() != 111) && (ec.value() != 10060) && (ec.value() != 10061) && (ec.value() != 10064) && (ec.value() != 10061))) // Connection failed due to no response, no route or active refusal _log.Log(LOG_NORM, "Panasonic Plugin: (%s) Connect to '%s:%s' failed: (%d) %s", m_Name.c_str(), m_IP.c_str(), (m_Port[0] != '-' ? m_Port.c_str() : m_Port.substr(1).c_str()), ec.value(), ec.message().c_str()); return false; } } } catch (std::exception& e) { _log.Log(LOG_ERROR, "Panasonic Plugin: (%s) Exception: '%s' connecting to '%s'", m_Name.c_str(), e.what(), m_IP.c_str()); return false; } return true; }
void TCPClient::setupSocket(boost::asio::ip::tcp::socket& socket) { if (!_setup_socket) { _setup_socket = true; socket.set_option(boost::asio::ip::tcp::no_delay(true)); } }
bool server::read_socket_from_parent(int fd_socket, boost::asio::ip::tcp::socket& socket) { typedef boost::asio::ip::tcp::socket::native_type native_type; #if __APPLE__ // macos is special... assert(CMSG_SPACE(sizeof(int)) == 16); #endif struct msghdr msg; union { struct cmsghdr cm; #if __APPLE__ char control[16]; #else char control[CMSG_SPACE(sizeof(int))]; #endif } control_un; msg.msg_control = control_un.control; msg.msg_controllen = sizeof(control_un.control); msg.msg_name = NULL; msg.msg_namelen = 0; boost::asio::ip::tcp::socket::endpoint_type peer_endpoint; struct iovec iov[1]; iov[0].iov_base = peer_endpoint.data(); iov[0].iov_len = peer_endpoint.capacity(); msg.msg_iov = iov; msg.msg_iovlen = 1; bool result = false; int n = recvmsg(fd_socket, &msg, 0); if (n >= 0) { peer_endpoint.resize(n); struct cmsghdr* cmptr CMSG_FIRSTHDR(&msg); if (cmptr != NULL and cmptr->cmsg_len == CMSG_LEN(sizeof(int))) { if (cmptr->cmsg_level != SOL_SOCKET) cerr << "control level != SOL_SOCKET" << endl; else if (cmptr->cmsg_type != SCM_RIGHTS) cerr << "control type != SCM_RIGHTS"; else { int fd = *(reinterpret_cast<native_type*>(CMSG_DATA(cmptr))); if (fd >= 0) { socket.assign(peer_endpoint.protocol(), fd); result = true; } } } else cerr << "No file descriptor was passed" << endl; }
int Run() { // ----------- Thread_TcpCommClient_Recv ----------- int iParam1 = 0; pthread_t pthread_TcpCommClient_Recv; if(pthread_create(&pthread_TcpCommClient_Recv, NULL, Thread_TcpCommClient_Recv, (void*)this) != 0) { printf("Failed:Thread_TcpCommClient_Recv\n"); } else { printf("Initiate:Thread_TcpCommClient_Recv\n"); usleep(100000); } // ----------- Thread_TcpCommClient_Send ----------- int iParam2 = 0; pthread_t pthread_TcpCommClient_Send; if(pthread_create(&pthread_TcpCommClient_Send, NULL, Thread_TcpCommClient_Send, (void*)this) != 0) { printf("Failed:Thread_TcpCommClient_Send\n"); } else { printf("Initiate:Thread_TcpCommClient_Send\n"); usleep(100000); } while( ros::ok() ) { ros::spinOnce(); usleep(30000); } if( m_Socket.is_open() ) { m_Socket.close(); } return 0; }
void do_write(boost::asio::ip::tcp::socket& socket, boost::asio::yield_context yield) { using namespace boost::asio::ip; std::time_t now = std::time(0); std::string data = std::ctime(&now); boost::asio::async_write(socket, boost::asio::buffer(data), yield); socket.shutdown(tcp::socket::shutdown_send); }
void run_socket_io(boost::asio::ip::tcp::socket& socket) { std::array<char, 1024> read_buffer; std::array<char, 1024> write_buffer; socket.async_read_some(boost::asio::buffer(write_buffer, 1024), [&write_buffer](const boost::system::error_code& ec, std::size_t length) { if (!ec) std::cout.write(write_buffer.data(), length); }); while (std::cin.getline(read_buffer.data(), 1024)) { socket.send( boost::asio::buffer(read_buffer, std::strlen(read_buffer.data()))); } }
virtual void send(raw_data& data) { bool write_in_progress = !buffer_write_queue_.empty(); buffer_write_queue_.push_back(data); if (!write_in_progress) { socket_.async_write_some( boost::asio::buffer(buffer_write_queue_.front().bytes, buffer_write_queue_.front().length), boost::bind(&session::handle_write, shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred)); } }
std::vector<justine::sampleclient::MyShmClient::Cop> justine::sampleclient::MyShmClient::initcops ( boost::asio::ip::tcp::socket & socket ) { boost::system::error_code err; size_t length = std::sprintf ( data, "<init guided %s 10 c>", m_teamname.c_str() ); socket.send ( boost::asio::buffer ( data, length ) ); length = socket.read_some ( boost::asio::buffer ( data ), err ); if ( err == boost::asio::error::eof ) { // TODO } else if ( err ) { throw boost::system::system_error ( err ); } /* reading all gangsters into a vector */ int idd {0}; int f, t; char c; int n {0}; int nn {0}; std::vector<Cop> cops; while ( std::sscanf ( data+nn, "<OK %d %d/%d %c>%n", &idd, &f, &t, &c, &n ) == 4 ) { nn += n; cops.push_back ( idd ); } std::cout.write ( data, length ); std::cout << "Command INIT sent." << std::endl; return cops; }
void startRead() { checkNotReading(true); reading = true; readBuff.ensure_write_space(MAX_READ_BYTES_ONCE); socket.async_read_some(boost::asio::buffer(readBuff.wt_ptr(), readBuff.writeable_bytes()), boost::bind(&TcpConnection::handleRead, shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred)); }
void AsyncLoopSocket(boost::function<TaskState()> doWork, boost::asio::ip::tcp::socket& sock, bool isRead) { if (sock.get_io_service().stopped()) { return; } TaskState st = doWork(); if (st == TASK_WORKING) { if (isRead) { sock.async_read_some(boost::asio::null_buffers(), bind(AsyncLoopSocket, doWork, boost::ref(sock), isRead)); } else { sock.async_write_some(boost::asio::null_buffers(), bind(AsyncLoopSocket, doWork, boost::ref(sock), isRead)); } return; } // Work is over. stop any outstanding events. // NOTE: this isn't 100% reliable, and there may be events that linger in the queue. // The next time we reset() and run() the io_service, these events will be processed, // and io_service::stopped() will return false, because we've just done reset() and run(). // The state management (SSHSession::State) is our first step in controlling this, and we // may need to implement our own cancel mechanism // // this io_service feature poses an additional problem - by spreading the implementation // responsibility across multiple classes, we create scenarios where io_service's queue // may contain outstanding events referring to objects that were, in the meantime, destroyed. // this is why we're favouring, for now, the use of AsyncLoopTimer, where we can use an // io_service for each timer, and destroy it right after being used. this makes sure we // process no "zombie" outstanding events. sock.get_io_service().stop(); }
inline void connection::handle_write(const boost::system::error_code& e) { if (!e) { // Initiate graceful connection closure. boost::system::error_code ignored_ec; socket_.shutdown(boost::asio::ip::tcp::socket::shutdown_both, ignored_ec); } // No new asynchronous operations are started. This means that all shared_ptr // references to the connection object will disappear and the object will be // destroyed automatically after this handler returns. The connection class's // destructor closes the socket. }
/** * Вызывается всякий раз, когда данные получены. */ static void handleRead( ba::ip::tcp::socket& readFrom, ba::ip::tcp::socket& writeTo, char* readBuffer, size_t bytes, const boost::system::error_code& e ) { #ifdef _DEBUG const std::string data( readBuffer, readBuffer + bytes ); std::cout << data << std::endl; #endif // отправляем полученные данные "другой стороне" writeTo.send( ba::buffer( readBuffer, bytes ) ); // читаем ещё данные с "этой стороны" readFrom.async_read_some( ba::buffer( readBuffer, 1024 ), boost::bind( handleRead, boost::ref( readFrom ), boost::ref( writeTo), readBuffer, ba::placeholders::bytes_transferred, ba::placeholders::error ) ); }
void justine::sampleclient::ShmClient::pos ( boost::asio::ip::tcp::socket & socket, int id ) { boost::system::error_code err; size_t length = std::sprintf ( data, "<pos " ); length += std::sprintf ( data+length, "%d %u %u>", id, 2969934868u, 651365957u ); socket.send ( boost::asio::buffer ( data, length ) ); length = socket.read_some ( boost::asio::buffer ( data ), err ); if ( err == boost::asio::error::eof ) { // TODO } else if ( err ) { throw boost::system::system_error ( err ); } std::cout.write ( data, length ); std::cout << "Command POS sent." << std::endl; }
inline void connection::start() { socket_.async_read_some(boost::asio::buffer(buffer_), strand_.wrap( boost::bind(&connection::handle_read, shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred))); }