bool
Monitor::setSenders()
{
//std::cerr << "Monitor::setSenders() version=" << version() << std::endl;
rcss::SerializerMonitor::Creator ser_cre;
if ( ! rcss::SerializerMonitor::factory().getCreator( ser_cre,
(int)version() ) )
{
std::cout << "Unsupported monitor protocol version. version=" << version()
<< std::endl;
return false;
}
const rcss::SerializerMonitor::Ptr ser = ser_cre();
if ( ! ser )
{
std::cout << "Could not create monitor serializer. " << std::endl;
return false;
}
//
// disp sender
//
{
rcss::DispSenderMonitor::Params disp_params( getTransport(),
*this,
ser,
M_stadium );
rcss::DispSenderMonitor::Creator disp_cre;
if ( ! rcss::DispSenderMonitor::factory().getCreator( disp_cre,
(int)version() ) )
{
std::cerr << "failed to create DispSenderMonitor v" << version()
<< std::endl;
return false;
}
M_observer->setDispSender( disp_cre( disp_params ) );
}
//
// init sender
//
{
rcss::InitSenderMonitor::Params init_params( getTransport(),
*this,
ser,
M_stadium );
rcss::InitSenderMonitor::Creator init_cre;
if ( ! rcss::InitSenderMonitor::factory().getCreator( init_cre,
(int)version() ) )
{
std::cerr << "failed to create InitSenderMonitor v" << version()
<< std::endl;
return false;
}
M_init_observer->setInitSender( init_cre( init_params ) );
}
return true;
}
void BaseExecutionContext::write(CStrRef s) {
#ifdef TAINTED
if (!getTransport() && !m_out) {
// We are running a PHP script and we are about to echo to stdout
TaintWarning::WarnIfTainted(s, TAINT_BIT_HTML);
} else if (getTransport() && m_buffers.size() == 2) {
// We are responding to a request and we are about to echo to stdout
TaintWarning::WarnIfTainted(s, TAINT_BIT_HTML);
}
#endif
write(s.data(), s.size());
}
void
GenericLinkService::checkCongestionLevel(lp::Packet& pkt)
{
ssize_t sendQueueLength = getTransport()->getSendQueueLength();
// This operation requires that the transport supports retrieving current send queue length
if (sendQueueLength < 0) {
return;
}
// To avoid overflowing the queue, set the congestion threshold to at least half of the send
// queue capacity.
size_t congestionThreshold = m_options.defaultCongestionThreshold;
if (getTransport()->getSendQueueCapacity() >= 0) {
congestionThreshold = std::min(congestionThreshold,
static_cast<size_t>(getTransport()->getSendQueueCapacity()) /
DEFAULT_CONGESTION_THRESHOLD_DIVISOR);
}
if (sendQueueLength > 0) {
NFD_LOG_FACE_TRACE("txqlen=" << sendQueueLength << " threshold=" << congestionThreshold <<
" capacity=" << getTransport()->getSendQueueCapacity());
}
if (static_cast<size_t>(sendQueueLength) > congestionThreshold) { // Send queue is congested
const auto now = time::steady_clock::now();
if (now >= m_nextMarkTime || now >= m_lastMarkTime + m_options.baseCongestionMarkingInterval) {
// Mark at most one initial packet per baseCongestionMarkingInterval
if (m_nMarkedSinceInMarkingState == 0) {
m_nextMarkTime = now;
}
// Time to mark packet
pkt.set<lp::CongestionMarkField>(1);
++nCongestionMarked;
NFD_LOG_FACE_DEBUG("LpPacket was marked as congested");
++m_nMarkedSinceInMarkingState;
// Decrease the marking interval by the inverse of the square root of the number of packets
// marked in this incident of congestion
m_nextMarkTime += time::nanoseconds(static_cast<time::nanoseconds::rep>(
m_options.baseCongestionMarkingInterval.count() /
std::sqrt(m_nMarkedSinceInMarkingState)));
m_lastMarkTime = now;
}
}
else if (m_nextMarkTime != time::steady_clock::TimePoint::max()) {
// Congestion incident has ended, so reset
NFD_LOG_FACE_DEBUG("Send queue length dropped below congestion threshold");
m_nextMarkTime = time::steady_clock::TimePoint::max();
m_nMarkedSinceInMarkingState = 0;
}
}
/**
* @given transaction field values and sample command values, reference tx
* @when create transaction with sample command using transaction builder
* @then transaction is built correctly
*/
TEST(ProtoTransaction, Builder) {
iroha::protocol::Transaction proto_tx = generateEmptyTransaction();
std::string account_id = "admin@test", asset_id = "coin#test",
amount = "10.00";
auto command =
proto_tx.mutable_payload()->add_commands()->mutable_add_asset_quantity();
command->CopyFrom(generateAddAssetQuantity(account_id, asset_id));
auto keypair =
shared_model::crypto::CryptoProviderEd25519Sha3::generateKeypair();
auto signedProto = shared_model::crypto::CryptoSigner<>::sign(
shared_model::crypto::Blob(proto_tx.payload().SerializeAsString()),
keypair);
auto sig = proto_tx.add_signatures();
sig->set_pubkey(shared_model::crypto::toBinaryString(keypair.publicKey()));
sig->set_signature(shared_model::crypto::toBinaryString(signedProto));
auto tx = shared_model::proto::TransactionBuilder()
.creatorAccountId(creator_account_id)
.addAssetQuantity(account_id, asset_id, amount)
.createdTime(created_time)
.quorum(1)
.build();
auto signedTx = tx.signAndAddSignature(keypair).finish();
auto &proto = signedTx.getTransport();
ASSERT_EQ(proto_tx.SerializeAsString(), proto.SerializeAsString());
}
void ClientStub::flushBatch(unsigned int timeoutMs)
{
CurrentClientStubSentry sentry(*this);
if (timeoutMs == 0)
{
timeoutMs = getRemoteCallTimeoutMs();
}
try
{
std::vector<ByteBuffer> buffers;
buffers.push_back( ByteBuffer(mBatchBufferPtr) );
int err = getTransport().send(*this, buffers, timeoutMs);
RCF_UNUSED_VARIABLE(err);
mBatchBufferPtr->resize(0);
++mBatchCount;
mBatchMessageCount = 0;
}
catch(const RemoteException & e)
{
RCF_UNUSED_VARIABLE(e);
mEncodedByteBuffers.resize(0);
throw;
}
catch(...)
{
mEncodedByteBuffers.resize(0);
disconnect();
throw;
}
}
/* Description: Create a mamaPublisher then destroy it.
*
* Expected Result: MAMA_STATUS_OK
*/
TEST_F (MamaPublisherTestC, CreateDestroy)
{
mamaPublisher publisher = NULL;
mamaTransport tport = NULL;
const char* source = getSource();
pubOnCreateCount = 0;
pubOnErrorCount = 0;
pubOnDestroyCount = 0;
ASSERT_EQ (MAMA_STATUS_OK,
mamaTransport_allocate (&tport));
ASSERT_EQ (MAMA_STATUS_OK,
mamaTransport_create (tport, getTransport(), mBridge));
ASSERT_EQ (MAMA_STATUS_OK,
mamaPublisher_create (&publisher, tport, source, NULL, NULL));
ASSERT_EQ (MAMA_STATUS_OK,
mamaPublisher_destroy (publisher));
ASSERT_EQ (MAMA_STATUS_OK,
mamaTransport_destroy (tport));
}
void EClientSocket::onSend()
{
if( !handleSocketError())
return;
getTransport()->sendBufferedData();
}
TEST(H2ClientConnectionTest, ServerCloseSocketImmediate) {
folly::SocketAddress saddr;
saddr.setFromLocalPort(static_cast<uint16_t>(0));
proxygen::HTTPServer::IPConfig cfg{saddr,
proxygen::HTTPServer::Protocol::HTTP2};
auto server =
proxygen::ScopedHTTPServer::start(cfg, proxygen::HTTPServerOptions{});
ASSERT_NE(nullptr, server);
const auto port = server->getPort();
ASSERT_NE(0, port);
folly::EventBase evb;
folly::SocketAddress addr;
addr.setFromLocalPort(port);
async::TAsyncSocket::UniquePtr sock(new async::TAsyncSocket(&evb, addr));
auto conn = H2ClientConnection::newHTTP2Connection(std::move(sock));
EXPECT_TRUE(conn->good());
server.reset(); // server closes connection
evb.loop();
EXPECT_FALSE(conn->good());
EXPECT_EQ(nullptr, conn->getTransport());
}
std::unique_ptr<folly::IOBuf>
HeaderServerChannel::removeFrame(IOBufQueue* q, size_t& remaining) {
// removeHeader will set seqid in header_.
// For older clients with seqid in the protocol, header_
// will dig in to the protocol to get the seqid correctly.
std::unique_ptr<folly::IOBuf> buf;
try {
buf = header_->removeHeader(q, remaining);
} catch (const std::exception& e) {
LOG(ERROR) << "Received invalid request from client: "
<< folly::exceptionStr(e) << " "
<< getTransportDebugString(getTransport());
return buf;
}
if (!buf) {
return buf;
}
if (!header_->isSupportedClient() &&
header_->getClientType() != THRIFT_HEADER_SASL_CLIENT_TYPE) {
LOG(ERROR) << "Server rejecting unsupported client type "
<< header_->getClientType();
header_->checkSupportedClient();
}
// In order to allow negotiation to happen when the client requests
// sasl but it's not supported, we don't throw an exception in the
// sasl case. Instead, we let the message bubble up, and check if
// the client is supported in handleSecurityMessage called from the
// messageReceived callback.
return buf;
}
/* Description: Create a mamaPublisher and get its transport
*
* Expected Result: MAMA_STATUS_OK
*/
TEST_F (MamaPublisherTestC, GetTransport)
{
mamaPublisher publisher = NULL;
mamaTransport tport = NULL;
const char* symbol = "SYM";
const char* source = "SRC";
ASSERT_EQ (MAMA_STATUS_OK,
mamaTransport_allocate (&tport));
ASSERT_EQ (MAMA_STATUS_OK,
mamaTransport_create (tport, getTransport(), mBridge));
ASSERT_EQ (MAMA_STATUS_OK,
mamaPublisher_create (&publisher, tport, symbol, source, NULL));
ASSERT_EQ(tport, mamaPublisherImpl_getTransportImpl (publisher));
ASSERT_EQ(tport, mamaPublisherImpl_getTransportImpl (publisher));
ASSERT_EQ (MAMA_STATUS_OK,
mamaPublisher_destroy (publisher));
ASSERT_EQ (MAMA_STATUS_OK,
mamaTransport_destroy (tport));
ASSERT_EQ (0, pubOnCreateCount);
ASSERT_EQ (0, pubOnErrorCount);
ASSERT_EQ (0, pubOnDestroyCount);
}
bool BlueCoreDeviceController::Implementation::isTransportReady( uint32 timeout )
{
// Are we connected at this instant?
if ( !mTransportReady )
mTransportReady = getTransport()->ready(timeout);
return mTransportReady ;
}
std::string ExecutionContext::getRequestUrl(size_t szLimit) {
Transport* t = getTransport();
std::string ret = t ? t->getUrl() : "";
if (szLimit != std::string::npos) {
ret = ret.substr(0, szLimit);
}
return ret;
}
void
DummyClientFace::construct(const Options& options)
{
static_pointer_cast<Transport>(getTransport())->onSendBlock.connect([this] (const Block& blockFromDaemon) {
Block packet(blockFromDaemon);
packet.encode();
lp::Packet lpPacket(packet);
Buffer::const_iterator begin, end;
std::tie(begin, end) = lpPacket.get<lp::FragmentField>();
Block block(&*begin, std::distance(begin, end));
if (block.type() == tlv::Interest) {
shared_ptr<Interest> interest = make_shared<Interest>(block);
if (lpPacket.has<lp::NackField>()) {
shared_ptr<lp::Nack> nack = make_shared<lp::Nack>(std::move(*interest));
nack->setHeader(lpPacket.get<lp::NackField>());
if (lpPacket.has<lp::NextHopFaceIdField>()) {
nack->setTag(make_shared<lp::NextHopFaceIdTag>(lpPacket.get<lp::NextHopFaceIdField>()));
}
if (lpPacket.has<lp::CongestionMarkField>()) {
nack->setTag(make_shared<lp::CongestionMarkTag>(lpPacket.get<lp::CongestionMarkField>()));
}
onSendNack(*nack);
}
else {
if (lpPacket.has<lp::NextHopFaceIdField>()) {
interest->setTag(make_shared<lp::NextHopFaceIdTag>(lpPacket.get<lp::NextHopFaceIdField>()));
}
if (lpPacket.has<lp::CongestionMarkField>()) {
interest->setTag(make_shared<lp::CongestionMarkTag>(lpPacket.get<lp::CongestionMarkField>()));
}
onSendInterest(*interest);
}
}
else if (block.type() == tlv::Data) {
shared_ptr<Data> data = make_shared<Data>(block);
if (lpPacket.has<lp::CachePolicyField>()) {
data->setTag(make_shared<lp::CachePolicyTag>(lpPacket.get<lp::CachePolicyField>()));
}
if (lpPacket.has<lp::CongestionMarkField>()) {
data->setTag(make_shared<lp::CongestionMarkTag>(lpPacket.get<lp::CongestionMarkField>()));
}
onSendData(*data);
}
});
if (options.enablePacketLogging)
this->enablePacketLogging();
if (options.enableRegistrationReply)
this->enableRegistrationReply();
m_processEventsOverride = options.processEventsOverride;
}
bool HHVM_FUNCTION(fastcgi_finish_request) {
auto context = g_context.getNoCheck();
auto transport = context->getTransport();
context->obFlushAll();
String content = context->obDetachContents();
transport->sendRaw((void*)content.data(), content.size());
transport->onSendEnd();
return true;
}
void
DummyClientFace::receive(const Data& data)
{
lp::Packet lpPacket(data.wireEncode());
addFieldFromTag<lp::IncomingFaceIdField, lp::IncomingFaceIdTag>(lpPacket, data);
addFieldFromTag<lp::CongestionMarkField, lp::CongestionMarkTag>(lpPacket, data);
static_pointer_cast<Transport>(getTransport())->receive(lpPacket.wireEncode());
}
void
DummyClientFace::receive(const Interest& interest)
{
lp::Packet lpPacket(interest.wireEncode());
addFieldFromTag<lp::IncomingFaceIdField, lp::IncomingFaceIdTag>(lpPacket, interest);
addFieldFromTag<lp::NextHopFaceIdField, lp::NextHopFaceIdTag>(lpPacket, interest);
addFieldFromTag<lp::CongestionMarkField, lp::CongestionMarkTag>(lpPacket, interest);
static_pointer_cast<Transport>(getTransport())->receive(lpPacket.wireEncode());
}
void SMTPConnection::startTLS()
{
try
{
sendRequest(SMTPCommand::STARTTLS());
shared_ptr <SMTPResponse> resp = readResponse();
if (resp->getCode() != 220)
{
throw SMTPCommandError("STARTTLS", resp->getText(),
resp->getCode(), resp->getEnhancedCode());
}
shared_ptr <tls::TLSSession> tlsSession = tls::TLSSession::create
(getTransport()->getCertificateVerifier(),
getTransport()->getSession()->getTLSProperties());
shared_ptr <tls::TLSSocket> tlsSocket =
tlsSession->getSocket(m_socket);
tlsSocket->handshake();
m_socket = tlsSocket;
m_secured = true;
m_cntInfos = make_shared <tls::TLSSecuredConnectionInfos>
(m_cntInfos->getHost(), m_cntInfos->getPort(), tlsSession, tlsSocket);
}
catch (const exceptions::command_error&)
{
// Non-fatal error
throw;
}
catch (...)
{
// Fatal error
internalDisconnect();
throw;
}
}
void
DummyClientFace::receive(const lp::Nack& nack)
{
lp::Packet lpPacket;
lpPacket.add<lp::NackField>(nack.getHeader());
Block interest = nack.getInterest().wireEncode();
lpPacket.add<lp::FragmentField>(make_pair(interest.begin(), interest.end()));
addFieldFromTag<lp::IncomingFaceIdField, lp::IncomingFaceIdTag>(lpPacket, nack);
addFieldFromTag<lp::CongestionMarkField, lp::CongestionMarkTag>(lpPacket, nack);
static_pointer_cast<Transport>(getTransport())->receive(lpPacket.wireEncode());
}
void MamaPublisherTest::SetUp(void)
{
// Save the this pointer in the member variable to get around gtest problems
m_this = this;
// Load the bridge
m_bridge = Mama::loadBridge(getMiddleware());
// Open mama
Mama::open();
// Transport
transportName = getTransport();
m_transport = new MamaTransport();
m_transport->create(transportName, m_bridge);
}
void ClientStub::setTransportProtocol(TransportProtocol protocol)
{
if (mTransportProtocol != protocol)
{
mTransportProtocol = protocol;
RcfSessionWeakPtr sessionWeakPtr = getTransport().getRcfSession();
bool isRegularConnection = (sessionWeakPtr == RcfSessionWeakPtr());
if (isRegularConnection)
{
disconnect();
clearTransportFilters();
}
else
{
mSetTransportProtocol = true;
}
}
}
/* Description: Create a mamaPublisher and mamaMsg, send the msg using
* mamaPublisher then destroy both.
*
* Expected Result: MAMA_STATUS_OK
*/
TEST_F (MamaPublisherTestC, Send)
{
mamaPublisher publisher = NULL;
mamaTransport tport = NULL;
const char* symbol = getSymbol();
const char* source = getSource();
mamaMsg msg = NULL;
pubOnCreateCount = 0;
pubOnErrorCount = 0;
pubOnDestroyCount = 0;
ASSERT_EQ (MAMA_STATUS_OK, mama_open());
ASSERT_EQ (MAMA_STATUS_OK,
mamaMsg_create (&msg));
ASSERT_EQ (MAMA_STATUS_OK,
mamaMsg_addString (msg, symbol, 101, source));
ASSERT_EQ (MAMA_STATUS_OK,
mamaTransport_allocate (&tport));
ASSERT_EQ (MAMA_STATUS_OK,
mamaTransport_create (tport, getTransport(), mBridge));
ASSERT_EQ (MAMA_STATUS_OK,
mamaPublisher_create (&publisher, tport, symbol, source, NULL));
ASSERT_EQ (MAMA_STATUS_OK,
mamaPublisher_send (publisher, msg));
ASSERT_EQ (MAMA_STATUS_OK,
mamaPublisher_destroy (publisher));
ASSERT_EQ (MAMA_STATUS_OK,
mamaTransport_destroy (tport));
ASSERT_EQ (MAMA_STATUS_OK, mama_close());
ASSERT_EQ (0, pubOnCreateCount);
ASSERT_EQ (0, pubOnErrorCount);
ASSERT_EQ (0, pubOnDestroyCount);
}
void Connection::negotiateCompleted(const NegotiateResponse* negotiateResponse, SignalException* error)
{
if(!error)
{
if( !(negotiateResponse->protocolVersion == "1.3" || negotiateResponse->protocolVersion == "1.2") )
{
onError(SignalException("Invalid protocol version", SignalException::InvalidProtocolVersion));
stop();
}
else
{
if(negotiateResponse->keepAliveTimeout > 0)
{
_keepAliveData = new KeepAliveData(negotiateResponse->keepAliveTimeout);
}
setConnectionState(*negotiateResponse);
connect(_transport, SIGNAL(transportStarted(SignalException*)), this, SLOT(transportStarted(SignalException*)));
getTransport()->start("");
}
}
else
{
if(_autoReconnect)
bool BlueCoreDeviceController::Implementation::startTransport()
{
return getTransport()->start();
}
/* Description: Create a mamaPublisher with event callbacks and mamaMsg, send the msg using
* mamaPublisher then destroy both. A non-entitled source is used to generate
* publisher error events. But the callbacks are not set, so no callbacks
* should be received.
*
* Expected Result: MAMA_STATUS_OK
*/
TEST_F (MamaPublisherTestC, EventSendWithCallbacksNoCallbacks)
{
mamaPublisher publisher = NULL;
mamaTransport tport = NULL;
const char* symbol = getSymbol();
const char* source = getBadSource();
mamaMsg msg = NULL;
mamaQueue queue = NULL;
mamaPublisherCallbacks* cb = NULL;
int i = 0;
int numErrors = 10;
pubOnCreateCount = 0;
pubOnErrorCount = 0;
pubOnDestroyCount = 0;
mamaPublisherCallbacks_allocate(&cb);
cb->onError = NULL;
cb->onCreate = NULL;
cb->onDestroy = NULL;
ASSERT_EQ (MAMA_STATUS_OK, mama_open());
ASSERT_EQ (MAMA_STATUS_OK,
mamaMsg_create (&msg));
ASSERT_EQ (MAMA_STATUS_OK,
mamaMsg_addString (msg, symbol, 101, source));
ASSERT_EQ (MAMA_STATUS_OK,
mama_getDefaultEventQueue (mBridge, &queue));
ASSERT_EQ (MAMA_STATUS_OK,
mamaTransport_allocate (&tport));
ASSERT_EQ (MAMA_STATUS_OK,
mamaTransport_create (tport, getTransport(), mBridge));
ASSERT_EQ (MAMA_STATUS_OK,
mamaTransport_setTransportTopicCallback (tport, (mamaTransportTopicCB) transportTopicCb, NULL));
ASSERT_EQ (MAMA_STATUS_OK,
mamaPublisher_createWithCallbacks (&publisher, tport, queue, symbol, source, NULL, cb, NULL));
for (i = 0; i < numErrors; i++)
{
ASSERT_EQ (MAMA_STATUS_OK,
mamaPublisher_send (publisher, msg));
}
ASSERT_EQ (MAMA_STATUS_OK,
mamaPublisher_destroy (publisher));
ASSERT_EQ (MAMA_STATUS_OK,
mamaTransport_destroy (tport));
ASSERT_EQ (MAMA_STATUS_OK, mama_close());
ASSERT_EQ (0, pubOnCreateCount);
ASSERT_EQ (0, pubOnErrorCount);
ASSERT_EQ (0, pubOnDestroyCount);
mamaPublisherCallbacks_deallocate(cb);
}
void BlueCoreDeviceController::Implementation::setDataWatch ( DataWatcher * w )
{
getTransport()->setDataWatch ( w );
}
bool EClientSocket::eConnectImpl(int clientId, bool extraAuth, ConnState* stateOutPt)
{
// resolve host
struct hostent* hostEnt = gethostbyname( host().c_str());
if ( !hostEnt) {
getWrapper()->error( NO_VALID_ID, CONNECT_FAIL.code(), CONNECT_FAIL.msg());
return false;
}
// create socket
m_fd = socket(AF_INET, SOCK_STREAM, 0);
// cannot create socket
if( m_fd < 0) {
getWrapper()->error( NO_VALID_ID, FAIL_CREATE_SOCK.code(), FAIL_CREATE_SOCK.msg());
return false;
}
// starting to connect to server
struct sockaddr_in sa;
memset( &sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_port = htons( port());
sa.sin_addr.s_addr = ((in_addr*)hostEnt->h_addr)->s_addr;
// try to connect
if( (connect( m_fd, (struct sockaddr *) &sa, sizeof( sa))) < 0) {
// error connecting
SocketClose( m_fd);
m_fd = -1;
getWrapper()->error( NO_VALID_ID, CONNECT_FAIL.code(), CONNECT_FAIL.msg());
return false;
}
getTransport()->fd(m_fd);
// set client id
setClientId( clientId);
setExtraAuth( extraAuth);
int res = sendConnectRequest();
if (res < 0 && !handleSocketError())
return false;
if( !isConnected()) {
if( connState() != CS_DISCONNECTED) {
assert( connState() == CS_REDIRECT);
if( stateOutPt) {
*stateOutPt = connState();
}
eDisconnect();
}
return false;
}
// set socket to non-blocking state
if ( !SetSocketNonBlocking(m_fd)) {
// error setting socket to non-blocking
eDisconnect();
getWrapper()->error( NO_VALID_ID, CONNECT_FAIL.code(), CONNECT_FAIL.msg());
return false;
}
assert( connState() == CS_CONNECTED);
if( stateOutPt) {
*stateOutPt = connState();
}
if (!m_asyncEConnect) {
EReader reader(this, m_pSignal);
while (m_pSignal && !m_serverVersion && isSocketOK()) {
reader.checkClient();
m_pSignal->waitForSignal();
reader.processMsgs();
}
}
// successfully connected
return isSocketOK();
}
IpClientTransport &ClientStub::getIpTransport()
{
return dynamic_cast<IpClientTransport &>(getTransport());
}
void ExternalUpdateManager::doProfileResync()
{
getTransport()->sendProfileResync();
}
bool BlueCoreDeviceController_newStyle::Implementation::reconfigure_uart_baudrate(uint32 baudrate)
{
return getTransport()->reconfigure_uart_baudrate(baudrate);
}
ref <transport> session::getTransport(ref <security::authenticator> auth)
{
return (getTransport(m_props["transport.protocol"], auth));
}
