void RDORuntime::postProcess()
{
getTracer()->startWriting();
LPIResultList::iterator it = m_resultAllList.begin();
while (it != m_resultAllList.end())
{
try
{
(*it)->calcStat(this, getResults().getOStream());
}
catch (const RDORuntimeException&)
{}
++it;
}
try
{
parent_type::postProcess();
writeExitCode();
getTracer()->stopWriting();
}
catch (const RDORuntimeException& e)
{
writeExitCode();
getTracer()->stopWriting();
throw e;
}
}
void QueryResult::init(const FieldSelector& selector,
const IndexReaderPtr& pIndexReader,
const QueryHits& hits)
{
StoredFieldsReaderPtr pStoredFieldsReader = pIndexReader->createStoredFieldsReader();
if (pStoredFieldsReader.isNull())
{
return;
}
TimeProbe probe;
probe.start();
m_docs.reserve(hits.size());
setTracer(hits.getTracer());
setTotalHits(hits.getTotalHits());
QueryHits::Iterator it = hits.iterator();
while (it.hasNext())
{
const QueryHits::HitDoc& hitDoc = it.next();
ResultDocPtr pResDoc(new ResultDoc(hitDoc.getDocId(),
hitDoc.getScore(), selector.size()));
addDoc(pResDoc);
pStoredFieldsReader->getDocument(selector, *pResDoc);
}
probe.stop();
FX_QUERY_TRACE(INFO, getTracer(), "fetch field time [%d] ms",
(int32_t)probe.elapsed() / 1000);
}
void RDORuntime::writeExitCode()
{
std::string status;
switch (m_whyStop)
{
case rdo::simulation::report::ExitCode::OK : status = "NORMAL_TERMINATION"; break;
case rdo::simulation::report::ExitCode::NOMORE_EVENTS : status = "NO_MORE_EVENTS"; break;
case rdo::simulation::report::ExitCode::RUNTIME_ERROR : status = "RUN_TIME_ERROR"; break;
case rdo::simulation::report::ExitCode::USER_BREAK : status = "USER_BREAK"; break;
default: NEVER_REACH_HERE;
}
getTracer()->writeStatus(this, status);
}
shared_ptr <security::cert::certificateChain> TLSSocket_GnuTLS::getPeerCertificates() {
if (getTracer()) {
getTracer()->traceSend("Getting peer certificates");
}
unsigned int certCount = 0;
const gnutls_datum_t* rawData = gnutls_certificate_get_peers(
*m_session->m_gnutlsSession, &certCount
);
if (rawData == NULL) {
return null;
}
// Try X.509
gnutls_x509_crt_t* x509Certs = new gnutls_x509_crt_t[certCount];
for (unsigned int i = 0; i < certCount; ++i) {
gnutls_x509_crt_init(x509Certs + i);
int res = gnutls_x509_crt_import(x509Certs[i], rawData + i, GNUTLS_X509_FMT_DER);
if (res < 0) {
for (unsigned int j = 0 ; j <= i ; ++j) {
gnutls_x509_crt_deinit(x509Certs[j]);
}
// XXX more fine-grained error reporting?
delete [] x509Certs;
return null;
}
}
std::vector <shared_ptr <security::cert::certificate> > certs;
bool error = false;
for (unsigned int i = 0 ; i < certCount ; ++i) {
size_t dataSize = 0;
gnutls_x509_crt_export(x509Certs[i], GNUTLS_X509_FMT_DER, NULL, &dataSize);
std::vector <byte_t> data(dataSize);
gnutls_x509_crt_export(x509Certs[i], GNUTLS_X509_FMT_DER, &data[0], &dataSize);
shared_ptr <security::cert::X509Certificate> cert =
security::cert::X509Certificate::import(&data[0], dataSize);
if (cert != NULL) {
certs.push_back(cert);
} else {
error = true;
}
gnutls_x509_crt_deinit(x509Certs[i]);
}
delete [] x509Certs;
if (error) {
return null;
}
return make_shared <security::cert::certificateChain>(certs);
}
void TLSSocket_GnuTLS::handshake() {
shared_ptr <timeoutHandler> toHandler = m_wrapped->getTimeoutHandler();
if (toHandler) {
toHandler->resetTimeOut();
}
if (getTracer()) {
getTracer()->traceSend("Beginning SSL/TLS handshake");
}
// Start handshaking process
try {
while (true) {
resetException();
const int ret = gnutls_handshake(*m_session->m_gnutlsSession);
throwException();
if (ret < 0) {
if (ret == GNUTLS_E_AGAIN) {
if (gnutls_record_get_direction(*m_session->m_gnutlsSession) == 0) {
m_wrapped->waitForRead();
} else {
m_wrapped->waitForWrite();
}
} else if (ret == GNUTLS_E_INTERRUPTED) {
// Non-fatal error
} else {
TLSSession_GnuTLS::throwTLSException("gnutls_handshake", ret);
}
} else {
// Successful handshake
break;
}
}
} catch (...) {
throw;
}
// Verify server's certificate(s)
shared_ptr <security::cert::certificateChain> certs = getPeerCertificates();
if (certs == NULL) {
throw exceptions::tls_exception("No peer certificate.");
}
m_session->getCertificateVerifier()->verify(certs, getPeerName());
m_connected = true;
}
