PDUUnit.cpp

/*
 * PDUUnit.cpp
 *
 *  Created on: 26.02.2018
 *      Author: Micha Mueller
 */

#include "PDUUnit.h"
#include "timestamp.h"

#include <iostream>
#include <sstream>

#include <boost/foreach.hpp>
#include <boost/property_tree/xml_parser.hpp>

#include <openssl/ssl.h>
#include <openssl/err.h>
#include <openssl/bio.h>

PDUUnit::PDUUnit() {
	_ttl = 1000;
	_lastRefresh = 0;
	_host = "";
	_strand = NULL;
}

PDUUnit::~PDUUnit() {
	// TODO Auto-generated destructor stub
}

uint64_t PDUUnit::readValue(const xmlPathVector_t& xmlPath) {
	uint64_t now = getTimestamp();
	if (now >= _lastRefresh + MS_TO_NS(_ttl)) {
		refresh();
#ifdef DEBUG
		LOG(debug) << "PDUUnit " << _host << " refreshed XML-file";
#endif
	}

	std::string reading;
	boost::property_tree::ptree node = _ptree;
	for (size_t i = 0; i < xmlPath.size(); i++) {
		const std::string& path = std::get<0>(xmlPath[i]);
		const std::string& child = std::get<1>(xmlPath[i]);
		const attributesVector_t& attVec = std::get<2>(xmlPath[i]);

		unsigned matchCount;
		if (child != "") {
			BOOST_FOREACH(boost::property_tree::ptree::value_type &v, node.get_child(path)) {
				if (v.first == child) {
					matchCount = 0;
					for (size_t j = 0; j < attVec.size(); j++) {
						std::string attributeVal = v.second.get_child("<xmlattr>." + attVec[j].first).data();

						if (attributeVal != attVec[j].second) { //attribute values don't match
							break;
						} else {
							matchCount++;
						}
					}
					if (matchCount == attVec.size()) { //all attributes matched
						reading = v.second.data();
						node = v.second;
						break;
					}
				}
			}
		} else {	//child == ""
			reading = node.get(path, "");
			break;	//last (part of the) path
		}
	}

	if (reading == "") {
#ifdef DEBUG
		LOG(debug) << "PDU: Value not found!";
#endif
		return 0;
	}
#ifdef DEBUG
	LOG(debug) << "Read: " << reading;
#endif
	return stoul(reading);
}

void PDUUnit::initializeStrand(boost::asio::io_service& io) {
	if (!_strand) {
		_strand = new boost::asio::io_service::strand(io);
	}
}

void PDUUnit::refresh() {
	SSL_library_init();
	SSL_load_error_strings();
	ERR_load_BIO_strings();
	OpenSSL_add_all_algorithms();

	SSL_CTX*	ctx;
	BIO*		bio;

	ctx = SSL_CTX_new(SSLv23_method());

	if (!ctx) {
		LOG(error) << "OpenSSL: Could not create context: " << ERR_reason_error_string(ERR_get_error());
		return;
	}

	/*
	if (!SSL_CTX_load_verify_locations(ctx, "/home/micha/LRZ/dcdbOwnFork/deps/openssl-1.0.2l/certs/demo/ca-cert.pem", NULL)) {
		LOG(error) << "OpenSSL: Could not load certificate: " << ERR_reason_error_string(ERR_get_error());
		SSL_CTX_free(ctx);
		return;
	}
	*/

	bio = BIO_new_ssl_connect(ctx);

	BIO_set_conn_hostname(bio, _host.c_str());

	if(BIO_do_connect(bio) <= 0)
	{
		LOG(error) << "OpenSSL: Could not connect: " << ERR_reason_error_string(ERR_get_error());
	    BIO_free_all(bio);
	    SSL_CTX_free(ctx);
	    return;
	}

	size_t len = _request.length();
	const char* reqBuf = _request.c_str();	//request

	char resBuf[2048];	//response
	memset(resBuf, 0, 2048);

	// do not bother too long if a write/read failed. Sensor intervals are usually small, just try again when next sensor wants to read.
	// Current sensor has to use old value though.

	// send request
	if (BIO_write(bio, reqBuf, len) <= 0) {
		LOG(error) << "OpenSSL: Could not send request: " << ERR_reason_error_string(ERR_get_error());
		BIO_free_all(bio);
		SSL_CTX_free(ctx);
		return;
	}

	// read reply
	std::string response;
	while ((len = BIO_read(bio, resBuf, sizeof(resBuf))) > 0) {
                resBuf[len] = 0;
                response.append(resBuf);
        }

	if (len < 0) {
                std::cerr << "OpenSSL: Could not read response: " << ERR_reason_error_string(ERR_get_error()) << std::endl;
                BIO_free_all(bio);
                SSL_CTX_free(ctx);
                return;
        }

	BIO_free_all(bio);
	SSL_CTX_free(ctx);

	std::string xml = response.substr(response.find("<"));
	std::istringstream treeStream(xml);
	try {
		boost::property_tree::read_xml(treeStream, _ptree);
	} catch (const std::exception& e) {
		LOG(error) << "PDU: Got malformed XML repsonse from " << _host;
		return;
	}
	_lastRefresh = getTimestamp();
	return;
}