TEST_F(SSLSessionTest, SerializeDeserializeTest) {
std::string sessiondata;
{
int fds[2];
getfds(fds);
AsyncSSLSocket::UniquePtr clientSock(
new AsyncSSLSocket(clientCtx, &eventBase, fds[0], serverName));
auto clientPtr = clientSock.get();
AsyncSSLSocket::UniquePtr serverSock(
new AsyncSSLSocket(dfServerCtx, &eventBase, fds[1], true));
SSLHandshakeClient client(std::move(clientSock), false, false);
SSLHandshakeServerParseClientHello server(
std::move(serverSock), false, false);
eventBase.loop();
ASSERT_TRUE(client.handshakeSuccess_);
std::unique_ptr<SSLSession> sess =
folly::make_unique<SSLSession>(clientPtr->getSSLSession());
sessiondata = sess->serialize();
ASSERT_TRUE(!sessiondata.empty());
}
{
int fds[2];
getfds(fds);
AsyncSSLSocket::UniquePtr clientSock(
new AsyncSSLSocket(clientCtx, &eventBase, fds[0], serverName));
auto clientPtr = clientSock.get();
std::unique_ptr<SSLSession> sess =
folly::make_unique<SSLSession>(sessiondata);
ASSERT_NE(sess.get(), nullptr);
clientSock->setSSLSession(sess->getRawSSLSessionDangerous(), true);
AsyncSSLSocket::UniquePtr serverSock(
new AsyncSSLSocket(dfServerCtx, &eventBase, fds[1], true));
SSLHandshakeClient client(std::move(clientSock), false, false);
SSLHandshakeServerParseClientHello server(
std::move(serverSock), false, false);
eventBase.loop();
ASSERT_TRUE(client.handshakeSuccess_);
ASSERT_TRUE(clientPtr->getSSLSessionReused());
}
}
// ****************************************************************************
// *** ProviderListenerLoop
// ****************************************************************************
void
khResourceManager::ProviderListenerLoop(void) throw()
{
try {
TCPListener serverSock(SockAddr(InetAddr::IPv4Any,
FusionConnection::khResourceManagerPort));
while (1) {
try {
FusionConnection::Handle provider
(FusionConnection::AcceptClient(serverSock));
if (theSystemManager.WantExit()) {
break;
}
// get initial info about provider
// will throw exception if times out
ProviderConnectMsg connreq;
provider->ReceiveNotify(connreq, SYSMAN_PROVIDER_TIMEOUT);
{
khLockGuard lock(mutex);
// will link himself into my providers list
// and will spawn own handler thread for reading
(void) new khResourceProviderProxy(connreq, provider);
}
} catch (const std::exception &e) {
notify(NFY_WARN,
"Caught exception in resource manager server loop: %s",
e.what());
} catch (...) {
notify(NFY_WARN, "Caught exception in resource manager server loop");
}
}
} catch (const std::exception &e) {
notify(NFY_WARN, "Unable to open server socket: %s", e.what());
} catch (...) {
notify(NFY_WARN, "Unable to open server socket");
}
theSystemManager.SetWantExit();
}
TEST_F(SSLSessionTest, GetSessionID) {
int fds[2];
getfds(fds);
AsyncSSLSocket::UniquePtr clientSock(
new AsyncSSLSocket(clientCtx, &eventBase, fds[0], serverName));
auto clientPtr = clientSock.get();
AsyncSSLSocket::UniquePtr serverSock(
new AsyncSSLSocket(dfServerCtx, &eventBase, fds[1], true));
SSLHandshakeClient client(std::move(clientSock), false, false);
SSLHandshakeServerParseClientHello server(
std::move(serverSock), false, false);
eventBase.loop();
ASSERT_TRUE(client.handshakeSuccess_);
std::unique_ptr<SSLSession> sess =
folly::make_unique<SSLSession>(clientPtr->getSSLSession());
ASSERT_NE(sess, nullptr);
auto sessID = sess->getSessionID();
ASSERT_GE(sessID.length(), 0);
}
int main(int argc, char *argv[]) {
try{
TCPServerSocket serverSock(SV_PORT);
while(1){
TCPSocket *sock = serverSock.accept();
pthread_t th;
if (pthread_create(&th, NULL, connHandler, (void *) sock) != 0){
cerr << "Error while creating pthread" << endl;
}
else{
}
}
}
catch(SocketException &e){
cerr << e.what() << endl;
exit(1);
}
return 0;
}
