TransportTCPPtr TransportTCP::accept() { ROS_ASSERT(is_server_); sockaddr client_address; socklen_t len = sizeof(client_address); int new_sock = ::accept(sock_, (sockaddr *)&client_address, &len); if (new_sock >= 0) { ROSCPP_LOG_DEBUG("Accepted connection on socket [%d], new socket [%d]", sock_, new_sock); TransportTCPPtr transport(new TransportTCP(poll_set_, flags_)); if (!transport->setSocket(new_sock)) { ROS_ERROR("Failed to set socket on transport for socket %d", new_sock); } return transport; } else { ROS_ERROR("accept() on socket [%d] failed with error [%s]", sock_, last_socket_error_string()); } return TransportTCPPtr(); }
void f_thrift_protocol_write_binary(CObjRef transportobj, const String& method_name, int64_t msgtype, CObjRef request_struct, int seqid, bool strict_write) { PHPOutputTransport transport(transportobj); if (strict_write) { int32_t version = VERSION_1 | msgtype; transport.writeI32(version); transport.writeString(method_name.data(), method_name.size()); transport.writeI32(seqid); } else { transport.writeString(method_name.data(), method_name.size()); transport.writeI8(msgtype); transport.writeI32(seqid); } Variant spec = HHVM_FN(hphp_get_static_property)( request_struct->o_getClassName(), s_TSPEC, false); binary_serialize_spec(request_struct, transport, spec.toArray()); transport.flush(); }
bool uwsgi_handler::handle_request() { // Do something with the url for example // const std::string& url = request().var("REQUEST_URI"); // Or print all incoming variables // request().print_vars(); typedef tasks::net::uwsgi_thrift_transport<tasks::net::http_response> transport_type; typedef apache::thrift::protocol::TBinaryProtocol protocol_type; boost::shared_ptr<transport_type> transport(new transport_type(response_p())); boost::shared_ptr<protocol_type> protocol(new protocol_type(transport)); tasks::tools::thrift_server_writer<id_name, transport_type, protocol_type> writer("lookup", transport, protocol); id_name m; m.id = 33; m.name = "testtest"; writer.write(m); // Now send back a response response().set_status("200 OK"); response().set_header("Content-Type", "application/x-thrift"); send_response(); stats::inc_req(); return true; }
int main(int argc, char** argv) { QApplication application(argc,argv); ros::init(argc, argv, "pcl_view"); ros::NodeHandle n; ros::Rate loop_rate(100); ROS_INFO("Start"); CloudMaker *filter = new Filter(); Viewer *viewer = new Viewer(); viewer->setFPSIsDisplayed(true); viewer->setFilter(filter); viewer->setWindowTitle("animation"); image_transport::ImageTransport transport(n); image_transport::CameraSubscriber depth_sub = transport.subscribeCamera("/camera/depth/image_raw", 1, &Filter::depthCb, filter); viewer->show(); return application.exec(); }
int ModuleSpanningTree::OnStats(char statschar, userrec* user, string_list &results) { if ((statschar == 'c') || (statschar == 'n')) { for (unsigned int i = 0; i < Utils->LinkBlocks.size(); i++) { results.push_back(std::string(ServerInstance->Config->ServerName)+" 213 "+user->nick+" "+statschar+" *@"+(Utils->LinkBlocks[i].HiddenFromStats ? "<hidden>" : Utils->LinkBlocks[i].IPAddr)+" * "+Utils->LinkBlocks[i].Name.c_str()+" "+ConvToStr(Utils->LinkBlocks[i].Port)+" "+(Utils->LinkBlocks[i].Hook.empty() ? "plaintext" : Utils->LinkBlocks[i].Hook)+" "+(Utils->LinkBlocks[i].AutoConnect ? 'a' : '-')+'s'); if (statschar == 'c') results.push_back(std::string(ServerInstance->Config->ServerName)+" 244 "+user->nick+" H * * "+Utils->LinkBlocks[i].Name.c_str()); } results.push_back(std::string(ServerInstance->Config->ServerName)+" 219 "+user->nick+" "+statschar+" :End of /STATS report"); ServerInstance->SNO->WriteToSnoMask('t',"%s '%c' requested by %s (%s@%s)",(!strcmp(user->server,ServerInstance->Config->ServerName) ? "Stats" : "Remote stats"),statschar,user->nick,user->ident,user->host); return 1; } if (statschar == 'p') { /* show all server ports, after showing client ports. -- w00t */ for (unsigned int i = 0; i < Utils->Bindings.size(); i++) { std::string ip = Utils->Bindings[i]->IP; if (ip.empty()) ip = "*"; std::string transport("plaintext"); if (Utils->Bindings[i]->GetHook()) transport = InspSocketNameRequest(this, Utils->Bindings[i]->GetHook()).Send(); results.push_back(ConvToStr(ServerInstance->Config->ServerName) + " 249 "+user->nick+" :" + ip + ":" + ConvToStr(Utils->Bindings[i]->port)+ " (server, " + transport + ")"); } } return 0; }
void rotate(GLfloat x, GLfloat y, GLfloat z){ transport(-x_center[now], -y_center[now], -z_center[now], NO_UPDATE); GLfloat M[3][4][4] = {0}; for(int i = 0; i < 3; ++i) for(int j = 0; j < 4; ++j) M[i][j][j] = 1; const double PI = std::atan(1.0); const double ANGLE_X = PI * x / 180.0; const double ANGLE_Y = PI * y / 180.0; const double ANGLE_Z = PI * z / 180.0; const GLfloat COS[] = { std::cos(ANGLE_X), std::cos(ANGLE_Y), std::cos(ANGLE_Z) }; const GLfloat SIN[] = { std::sin(ANGLE_X), std::sin(ANGLE_Y), std::sin(ANGLE_Z) }; for(int i = 0; i < 3; ++i){ if (i == 0){ M[i][1][1] = M[i][2][2] = COS[i]; M[i][1][2] = -SIN[i]; M[i][2][1] = SIN[i]; } else if (i == 1){ M[i][0][0] = M[i][2][2] = COS[i]; M[i][0][2] = -SIN[i]; M[i][2][0] = SIN[i]; } else { M[i][0][0] = M[i][1][1] = COS[i]; M[i][0][1] = -SIN[i]; M[i][1][0] = SIN[i]; } GLfloat I[4][4] = {{1,0,0,0},{0,1,0,0},{0,0,1,0},{0,0,0,1}}; multiMatrix(geoMatrix[now], M[i], geoMatrix[now]); multiple_all_matrix(M[i]); copyMatrix(aMVP[now], I); } transport(x_center[now], y_center[now], z_center[now], NO_UPDATE); }
int main(int argc, char **argv) { typedef my::MyServiceClient client_type; typedef tht::TSocket socket_type; typedef tht::TFramedTransport transp_type; typedef thp::TBinaryProtocol prot_type; typedef boost::shared_ptr<tht::TSocket> socket_ptr_type; typedef boost::shared_ptr<tht::TTransport> transp_ptr_type; typedef boost::shared_ptr<thp::TProtocol> prot_ptr_type; const int port_num = 9999; const std::string address("localhost"); socket_ptr_type socket (new socket_type(address, port_num)); transp_ptr_type transport(new transp_type(socket) ); prot_ptr_type protocol (new prot_type(transport)); client_type client(protocol); try { transport->open(); my::MyValue res; std::string key1("key-1"); std::string val1("value-1"); client.myPut(res, key1, val1); std::cout << std::boolalpha << "response: " << '(' << res.exists << ',' << res.content << ')' << std::endl; client.myGet(res, key1); std::cout << std::boolalpha << "response: " << '(' << res.exists << ',' << res.content << ')' << std::endl; } catch(const thr::TException& e) { std::cerr << "error: " << e.what() << std::endl; } catch(const std::exception& e) { std::cerr << "error: " << e.what() << std::endl; } catch(...) { std::cerr << "error: " << "unknown" << std::endl; } transport->close(); return 0; }
LucidaServiceClient *TClient::creatLucidaClient(string host, int port) { boost::shared_ptr<TTransport> socket(new TSocket(host, port)); boost::shared_ptr<TTransport> transport(new TBufferedTransport(socket)); boost::shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport)); LucidaServiceClient *client = new LucidaServiceClient(protocol); transport->open(); return client; }
void XmlRPC::setTimeout(int Timeout){ m_timeout = Timeout; xmlrpc_c::clientXmlTransport_curl transport( xmlrpc_c::clientXmlTransport_curl::constrOpt() .timeout(m_timeout) // milliseconds ); }
SchedulerServiceClient *TClient::creatSchedulerClient(string host, int port) { boost::shared_ptr<TSocket> socket(new TSocket(host, port)); boost::shared_ptr<TTransport> transport(new TFramedTransport(socket)); boost::shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport)); SchedulerServiceClient *client = new SchedulerServiceClient(protocol); this->transport = transport; transport->open(); return client; }
void FullStateSenderPlayerV8::sendBall() { serializer().serializeFSBall( transport(), stadium().ball().pos().x, stadium().ball().pos().y, stadium().ball().vel().x, stadium().ball().vel().y ); }
static int setup_transport(void) { int rv; rv = transport()->init(message_recv); if (rv < 0) { log_error("failed to init booth_transport %s", transport()->name); goto out; } rv = booth_transport[TCP].init(NULL); if (rv < 0) { log_error("failed to init booth_transport[TCP]"); goto out; } out: return rv; }
XmlRPC::XmlRPC(std::string serverurl, int port, bool authrequired, int Timeout) : m_serverurl(serverurl), m_port(port), m_authrequired(authrequired), m_timeout(Timeout) { xmlrpc_c::clientXmlTransport_curl transport( xmlrpc_c::clientXmlTransport_curl::constrOpt() .timeout(m_timeout) // milliseconds ); m_authset = false; }
void matrixInit(){ //printf("Matrix Initialization!!\n"); for(int j = 0; j < 4; ++j) for(int k = 0; k < 4; ++k) geoMatrix[now][j][k] = (j == k) ? 1 : 0; transport(-x_center[now], -y_center[now], -z_center[now]); scaleAll(); }
std::unique_ptr<TcpTransport> TcpTransport::NewTransport(std::unique_ptr<Socket> socket, std::string* error) { std::unique_ptr<TcpTransport> transport(new TcpTransport(std::move(socket))); if (!transport->InitializeProtocol(error)) { return nullptr; } return transport; }
void FullStateSenderPlayerV5::sendFullState() { static const char * playmode_string[] = PLAYMODE_STRINGS; // send begining of FS serializer().serializeFSBegin( transport(), stadium().time() ); if ( stadium().playmode() == PM_FreeKick_Left && stadium().ballCatcher() ) { serializer().serializeFSPlayMode( transport(), "goalie_catch_ball_l" ); } else if ( stadium().playmode() == PM_FreeKick_Right && stadium().ballCatcher() ) { serializer().serializeFSPlayMode( transport(), "goalie_catch_ball_r" ); } else { serializer().serializeFSPlayMode( transport(), playmode_string[stadium().playmode()] ); } serializer().serializeFSViewMode( transport(), ( self().highQuality() ? "high" : "low" ), ( self().viewWidth() == rcss::pcom::NARROW ? "narrow" : self().viewWidth() == rcss::pcom::WIDE ? "wide" : "normal" ) ); sendSelf(); sendScore(); sendBall(); const Stadium::PlayerCont::const_iterator end = stadium().players().end(); for ( Stadium::PlayerCont::const_iterator p = stadium().players().begin(); p != end; ++p ) { if ( ! (*p)->isEnabled() ) continue; sendPlayer( *(*p) ); } // send end of FS serializer().serializeFSEnd( transport() ); transport() << std::ends << std::flush; }
Variant HHVM_FUNCTION(thrift_protocol_read_binary_struct, const Variant& transportobj, const String& obj_typename) { PHPInputTransport transport(transportobj.toObject()); Object ret_val = createObject(obj_typename); Variant spec = HHVM_FN(hphp_get_static_property)(obj_typename, s_TSPEC, false); binary_deserialize_spec(ret_val, transport, spec.toArray()); return ret_val; }
void Entity::strafe(float units) { if(coll.checkCollision(this->areaID, (pos + side_vec * units))) { pos += glm::vec4(glm::vec3(side_vec.x, 0, side_vec.z), 1.0) * units; } Transport_data td = coll.checkPortals(areaID, pos, (pos + side_vec * units)); if(td.new_areaID != -1) { transport(td); } }
void InitSenderPlayerV1::sendScore() { int our_score = self().team()->point(); int opp_score = 0; if( self().side() == LEFT && stadium().teamRight().enabled() ) { opp_score = stadium().teamRight().point(); } else if( self().side() == RIGHT && stadium().teamLeft().enabled() ) { opp_score = stadium().teamLeft().point(); } serializer().serializeScore( transport(), stadium().time(), our_score, opp_score ); transport() << std::ends << std::flush; }
/*! * \brief Open connection to Cassandra cluster * \param db_id */ oac::CassandraClient* dbcassa_open(struct db_id* id) { try { boost::shared_ptr<att::TSocket> socket(new att::TSocket(id->host, id->port)); boost::shared_ptr<att::TTransport> transport(new att::TFramedTransport (socket)); boost::shared_ptr<atp::TProtocol> protocol(new atp::TBinaryProtocol(transport)); socket->setConnTimeout(cassa_conn_timeout); socket->setSendTimeout(cassa_send_timeout); socket->setRecvTimeout(cassa_recv_timeout); std::auto_ptr<oac::CassandraClient> cassa_client(new oac::CassandraClient(protocol)); transport->open(); if (!transport->isOpen()) { LM_ERR("Failed to open transport to Cassandra\n"); return 0; } /* database name -> keyspace */ cassa_client->set_keyspace(id->database); if(id->username && id->password) { oac::AuthenticationRequest au_req; std::map<std::string, std::string> cred; cred.insert(std::pair<std::string, std::string>("username", id->username)); cred.insert(std::pair<std::string, std::string>("password", id->password)); au_req.credentials = cred; try { cassa_client->login(au_req); } catch (const oac::AuthenticationException& autx) { LM_ERR("Authentication failure: Credentials not valid, %s\n", autx.why.c_str()); } catch (const oac::AuthorizationException & auzx) { LM_ERR("Authentication failure: Credentials not valid for the selected database, %s\n", auzx.why.c_str()); } } LM_DBG("Opened connection to Cassandra cluster %s:%d\n", id->host, id->port); return cassa_client.release(); } catch (const oac::InvalidRequestException &irx) { LM_ERR("Database does not exist %s, %s\n", id->database, irx.why.c_str()); } catch (const at::TException &tx) { LM_ERR("Failed to open connection to Cassandra cluster %s:%d, %s\n", id->database, id->port, tx.what()); } catch (const std::exception &ex) { LM_ERR("Failed: %s\n", ex.what()); } catch (...) { LM_ERR("Failed to open connection to Cassandra cluster\n"); } return 0; }
int main (void) { int towns_count, products_count; inputTP(&towns_count, &products_count); int graph[towns_count][towns_count]; int products[products_count][towns_count]; input(&towns_count, &products_count, &products , &graph); transport(towns_count, products_count); output(towns_count, products_count); }
///* Computation the function phi used to find the Critical Rate in the Jamishidian decomposition static double phi(ZCMarketData* ZCMarket, double r, double periodicity, double option_maturity, double contract_maturity, double SwaptionFixedRate, double a, double sigma) { int i, nb_payement; double ci, sum,sum_der,ti; double ZCPrice_T_ti; double r0, x0, x; Data data1, data2; Omega om; ZCPrice_T_ti = 0.; r0=0.0; x0=0.0; initial_short_rate(ZCMarket, &r0, &x0); sum=0.; sum_der=0.; ci = periodicity * SwaptionFixedRate; ti = option_maturity; nb_payement = (int)((contract_maturity-option_maturity)/periodicity); /* coefficients of P(0,T) */ bond_coeffs(ZCMarket, &data1, option_maturity, a, sigma, x0); x = sqrt(r); for(i=1; i<=nb_payement; i++) { ti += periodicity; /* coefficients of P(0,S) */ bond_coeffs(ZCMarket, &data2, ti, a, sigma, x0); /* omega distribution of P(T,S) */ transport(&om, data1, data2, a, sigma, x0); ZCPrice_T_ti = exp(-(om.B*r + om.b*M_SQRT2*x + om.c)); sum += ci * ZCPrice_T_ti; sum_der -= ci * ZCPrice_T_ti * (om.B + om.b/x); } sum += ZCPrice_T_ti; sum_der -= ZCPrice_T_ti * (om.B + om.b/x); return (sum-1.)/sum_der; }
TransportUDPPtr TransportUDP::createOutgoing(std::string host, int port, int connection_id, int max_datagram_size) { ROS_ASSERT(is_server_); TransportUDPPtr transport(new TransportUDP(poll_set_, flags_, max_datagram_size)); if (!transport->connect(host, port, connection_id)) { ROS_ERROR("Failed to create outgoing connection"); return TransportUDPPtr(); } return transport; }
void AudioSenderPlayerv1::sendCoachStdAudio( const rcss::clang::Msg & msg ) { if ( coachStdPredicate( msg ) ) { std::string name; switch( msg.getSide() ) { case LEFT: name = OLCOACH_NAME_L; break; case RIGHT: name = OLCOACH_NAME_R; break; default: // don't know what we have here so don't send anything return; } if ( msg.isSupported( listener().clangMinVer(), listener().clangMaxVer() ) ) { serializer().serializeCoachStdAudio( transport(), msg.getTimeSend(), name, msg ); } else { serializer().serializeCoachStdAudio( transport(), msg.getTimeSend(), name, rcss::clang::UnsuppMsg() ); } transport() << std::ends << std::flush; } }
void LibEventWorker::doJobImpl(LibEventJobPtr job, bool abort) { job->stopTimer(); evhttp_request *request = job->request; assert(m_opaque); LibEventServer *server = (LibEventServer*)m_opaque; LibEventTransport transport(server, request, m_id); #ifdef _EVENT_USE_OPENSSL if (evhttp_is_connection_ssl(job->request->evcon)) { transport.setSSL(); } #endif bool error = true; std::string errorMsg; if (abort) { transport.sendString("Service Unavailable", 503); return; } try { std::string cmd = transport.getCommand(); cmd = std::string("/") + cmd; if (server->shouldHandle(cmd)) { transport.onRequestStart(job->getStartTimer()); m_handler->handleRequest(&transport); error = false; } else { transport.sendString("Not Found", 404); return; } } catch (Exception &e) { if (Server::StackTraceOnError) { errorMsg = e.what(); } else { errorMsg = e.getMessage(); } } catch (std::exception &e) { errorMsg = e.what(); } catch (...) { errorMsg = "(unknown exception)"; } if (error) { if (RuntimeOption::ServerErrorMessage) { transport.sendString(errorMsg, 500); } else { transport.sendString(RuntimeOption::FatalErrorMessage, 500); } } }
void add_application(application app) { std::map<unsigned int, application>::iterator it = apps.insert(std::make_pair(app.application_id, application())).first; swap(app, it->second); if(!it->second.transport_protocol_descriptor.empty() && !it->second.ginga_location_descriptor.empty()) { typedef std::vector<char>::const_iterator iterator; typedef gts::descriptors::transport_protocol_descriptor<iterator> transport_protocol_descriptor; typedef transport_protocol_descriptor::protocol_id_iterator protocol_id_iterator; typedef transport_protocol_descriptor::transport_protocol_label_iterator transport_protocol_label_iterator; typedef transport_protocol_descriptor::selector_byte_iterator selector_byte_iterator; transport_protocol_descriptor transport_protocol (it->second.transport_protocol_descriptor.begin() , it->second.transport_protocol_descriptor.end()); if(* ++transport_protocol.begin() == gts::constants::etsi::protocol_ids::object_carousel) { selector_byte_iterator selector_byte_it = gts::iterators::next<3>(transport_protocol.begin()); typedef transport_protocol_descriptor::object_carousel_transport object_carousel_transport; object_carousel_transport transport(*selector_byte_it); typedef object_carousel_transport::component_tag_iterator component_tag_iterator; component_tag_iterator component_it = gts::iterators::next<4>(transport.begin()); std::cout << "=== Should filter component " << *component_it << std::endl; boost::optional<unsigned int> pid = sections::pid_from_component_tag(*component_it); if(pid) { dsmcc::start(it->second.dsmcc, *pid , boost::bind(&application_download_finish , it->second.application_id)); } else std::cout << "Couldn't find ES for component tag" << std::endl; } else { std::cout << "protocol id is " << * ++transport_protocol.begin() << std::endl; } } else { std::cout << "transport_protocol is empty" << std::endl; } }
void FullStateSenderPlayerV5::sendBall() { const float quantize_step = .001; serializer().serializeFSBall( transport(), Quantize( stadium().ball().pos().x, quantize_step ), Quantize( stadium().ball().pos().y, quantize_step ), Quantize( stadium().ball().vel().x, quantize_step ), Quantize( stadium().ball().vel().y, quantize_step ) ); }
MulticastSession* MulticastDataLink::find_or_create_session(MulticastPeer remote_peer) { ACE_GUARD_RETURN(ACE_SYNCH_RECURSIVE_MUTEX, guard, this->session_lock_, 0); MulticastSessionMap::iterator it(this->sessions_.find(remote_peer)); if (it != this->sessions_.end()) { MulticastSession_rch sess = it->second; return sess._retn(); } MulticastSession_rch session = this->session_factory_->create(transport()->reactor(), transport()->reactor_owner(), this, remote_peer); if (session.is_nil()) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: ") ACE_TEXT("MulticastDataLink::find_or_create_session: ") ACE_TEXT("failed to create session for remote peer: 0x%x!\n"), remote_peer), 0); } std::pair<MulticastSessionMap::iterator, bool> pair = this->sessions_.insert( MulticastSessionMap::value_type(remote_peer, session)); if (pair.first == this->sessions_.end()) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: ") ACE_TEXT("MulticastDataLink::find_or_create_session: ") ACE_TEXT("failed to insert session for remote peer: 0x%x!\n"), remote_peer), 0); } return session._retn(); }
void FullStateSenderPlayerV13::sendPlayer( const Player & p ) { char side = ( p.team()->side() == LEFT ? 'l' : 'r' ); serializer().serializeFSPlayerBegin( transport(), side, p.unum(), p.isGoalie(), p.playerTypeId(), p.pos().x, p.pos().y, p.vel().x, p.vel().y, Rad2Deg( p.angleBodyCommitted() ), Rad2Deg( p.angleNeckCommitted() ) ); if ( p.arm().isPointing() ) { rcss::geom::Vector2D arm_vec; p.arm().getRelDest( rcss::geom::Vector2D( p.pos().x, p.pos().y ), p.angleBodyCommitted() + p.angleNeckCommitted(), arm_vec ); serializer().serializeFSPlayerArm( transport(), arm_vec.getMag(), arm_vec.getHead() ); } serializer().serializeFSPlayerStamina( transport(), p.stamina(), p.effort(), p.recovery(), p.staminaCapacity() ); serializer().serializeFSPlayerState( transport(), p ); serializer().serializeFSPlayerEnd( transport() ); }
TEST(AsyncTransportTest, getSocketFromWrappedTransport) { AsyncSocket::UniquePtr transport(new AsyncSocket()); auto transportAddr = transport.get(); test::MockAsyncTransport wrapped1; test::MockAsyncTransport wrapped2; EXPECT_CALL(wrapped2, getWrappedTransport()) .WillOnce(Return(&wrapped1)); EXPECT_CALL(wrapped1, getWrappedTransport()) .WillOnce(Return(transportAddr)); auto sock = wrapped2.getUnderlyingTransport<AsyncSocket>(); ASSERT_EQ(transportAddr, sock); }