incremental
diff --git a/CMakeLists.txt b/CMakeLists.txt
index db4df43..1c4435e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -20,6 +20,8 @@
project(bmc-webserver CXX C)
+include( CTest )
+
set(CMAKE_CXX_STANDARD 14)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
@@ -184,8 +186,6 @@
set(SRC_FILES
- src/token_authorization_middleware.cpp
- src/security_headers_middleware.cpp
src/base64.cpp
${GENERATED_SRC_FILES}
)
diff --git a/crow/include/crow/http_response.h b/crow/include/crow/http_response.h
index c81446f..07493bc 100644
--- a/crow/include/crow/http_response.h
+++ b/crow/include/crow/http_response.h
@@ -47,18 +47,18 @@
}
response(response&& r) {
- CROW_LOG_WARNING << "Moving response containers";
+ CROW_LOG_DEBUG << "Moving response containers";
*this = std::move(r);
}
~response(){
- CROW_LOG_WARNING << "Destroying response";
+ CROW_LOG_DEBUG << "Destroying response";
}
response& operator=(const response& r) = delete;
response& operator=(response&& r) noexcept {
- CROW_LOG_WARNING << "Moving response containers";
+ CROW_LOG_DEBUG << "Moving response containers";
body = std::move(r.body);
json_value = std::move(r.json_value);
code = r.code;
@@ -70,7 +70,7 @@
bool is_completed() const noexcept { return completed_; }
void clear() {
- CROW_LOG_WARNING << "Clearing response containers";
+ CROW_LOG_DEBUG << "Clearing response containers";
body.clear();
json_value.clear();
code = 200;
diff --git a/crow/include/crow/http_server.h b/crow/include/crow/http_server.h
index 2ead557..5ed2927 100644
--- a/crow/include/crow/http_server.h
+++ b/crow/include/crow/http_server.h
@@ -113,7 +113,6 @@
timer.async_wait(handler);
};
timer.async_wait(handler);
- CROW_LOG_INFO << init_count;
init_count++;
try {
io_service_pool_[i]->run();
diff --git a/crow/include/crow/websocket.h b/crow/include/crow/websocket.h
index f29f13b..65a5836 100644
--- a/crow/include/crow/websocket.h
+++ b/crow/include/crow/websocket.h
@@ -18,6 +18,7 @@
virtual void send_binary(const std::string& msg) = 0;
virtual void send_text(const std::string& msg) = 0;
virtual void close(const std::string& msg = "quit") = 0;
+ virtual boost::asio::io_service& get_io_service() = 0;
virtual ~connection() {}
void userdata(void* u) { userdata_ = u; }
@@ -70,6 +71,10 @@
adaptor_.get_io_service().post(handler);
}
+ boost::asio::io_service& get_io_service(){
+ return adaptor_.get_io_service();
+ }
+
void send_pong(const std::string& msg) {
dispatch([this, msg] {
char buf[3] = "\x8A\x00";
diff --git a/include/pam_authenticate.hpp b/include/pam_authenticate.hpp
new file mode 100644
index 0000000..153dbc7
--- /dev/null
+++ b/include/pam_authenticate.hpp
@@ -0,0 +1,65 @@
+#include <security/pam_appl.h>
+
+// function used to get user input
+inline int pam_function_conversation(int num_msg,
+ const struct pam_message** msg,
+ struct pam_response** resp,
+ void* appdata_ptr) {
+ char* pass = (char*)malloc(strlen((char*)appdata_ptr) + 1);
+ strcpy(pass, (char*)appdata_ptr);
+
+ int i;
+
+ *resp = (pam_response*)calloc(num_msg, sizeof(struct pam_response));
+
+ for (i = 0; i < num_msg; ++i) {
+ /* Ignore all PAM messages except prompting for hidden input */
+ if (msg[i]->msg_style != PAM_PROMPT_ECHO_OFF) continue;
+
+ /* Assume PAM is only prompting for the password as hidden input */
+ resp[i]->resp = pass;
+ }
+
+ return PAM_SUCCESS;
+}
+
+class PamAuthenticator {
+ public:
+ inline bool authenticate(const std::string& username,
+ const std::string& password) {
+ const struct pam_conv local_conversation = {pam_function_conversation,
+ (char*)password.c_str()};
+ pam_handle_t* local_auth_handle = NULL; // this gets set by pam_start
+
+ int retval;
+ retval = pam_start("su", username.c_str(), &local_conversation,
+ &local_auth_handle);
+
+ if (retval != PAM_SUCCESS) {
+ //printf("pam_start returned: %d\n ", retval);
+ return false;
+ }
+
+ retval = pam_authenticate(local_auth_handle,
+ PAM_SILENT | PAM_DISALLOW_NULL_AUTHTOK);
+
+ if (retval != PAM_SUCCESS) {
+ if (retval == PAM_AUTH_ERR) {
+ //printf("Authentication failure.\n");
+ } else {
+ //printf("pam_authenticate returned %d\n", retval);
+ }
+ return false;
+ }
+
+ //printf("Authenticated.\n");
+ retval = pam_end(local_auth_handle, retval);
+
+ if (retval != PAM_SUCCESS) {
+ //printf("pam_end returned\n");
+ return false;
+ }
+
+ return true;
+ }
+};
\ No newline at end of file
diff --git a/include/security_headers_middleware.hpp b/include/security_headers_middleware.hpp
index 7e84543..19644f4 100644
--- a/include/security_headers_middleware.hpp
+++ b/include/security_headers_middleware.hpp
@@ -4,12 +4,45 @@
#include <crow/http_response.h>
namespace crow {
+static const std::string strict_transport_security_key =
+ "Strict-Transport-Security";
+static const std::string strict_transport_security_value =
+ "max-age=31536000; includeSubdomains; preload";
+
+static const std::string ua_compatability_key = "X-UA-Compatible";
+static const std::string ua_compatability_value = "IE=11";
+
+static const std::string xframe_key = "X-Frame-Options";
+static const std::string xframe_value = "DENY";
+
+static const std::string xss_key = "X-XSS-Protection";
+static const std::string xss_value = "1; mode=block";
+
+static const std::string content_security_key = "X-Content-Security-Policy";
+static const std::string content_security_value = "default-src 'self'";
+
struct SecurityHeadersMiddleware {
struct context {};
- void before_handle(crow::request& req, response& res, context& ctx);
+ void before_handle(crow::request& req,
+ response& res,
+ context& ctx) {}
- void after_handle(request& req, response& res, context& ctx);
+ void after_handle(request& /*req*/,
+ response& res,
+ context& ctx) {
+ /*
+ TODO(ed) these should really check content types. for example,
+ X-UA-Compatible header doesn't make sense when retrieving a JSON or
+ javascript file. It doesn't hurt anything, it's just ugly.
+ */
+ res.add_header(strict_transport_security_key,
+ strict_transport_security_value);
+ res.add_header(ua_compatability_key, ua_compatability_value);
+ res.add_header(xframe_key, xframe_value);
+ res.add_header(xss_key, xss_value);
+ res.add_header(content_security_key, content_security_value);
+ }
};
}
\ No newline at end of file
diff --git a/include/token_authorization_middleware.hpp b/include/token_authorization_middleware.hpp
index 214fd93..d333e6c 100644
--- a/include/token_authorization_middleware.hpp
+++ b/include/token_authorization_middleware.hpp
@@ -4,25 +4,145 @@
#include <crow/http_response.h>
#include <boost/container/flat_set.hpp>
+#include <base64.hpp>
+
+#include <pam_authenticate.hpp>
+
namespace crow {
struct User {};
-struct TokenAuthorizationMiddleware {
+using random_bytes_engine =
+ std::independent_bits_engine<std::default_random_engine, CHAR_BIT,
+ unsigned char>;
+
+template <class AuthenticationFunction>
+struct TokenAuthorization {
// TODO(ed) auth_token shouldn't really be passed to the context
// it opens the possibility of exposure by and endpoint.
// instead we should only pass some kind of "user" struct
struct context {
- //std::string auth_token;
+ // std::string auth_token;
};
- TokenAuthorizationMiddleware();
+ TokenAuthorization(){};
- void before_handle(crow::request& req, response& res, context& ctx);
+ void before_handle(crow::request& req, response& res, context& ctx) {
+ auto return_unauthorized = [&req, &res]() {
+ res.code = 401;
+ res.end();
+ };
- void after_handle(request& req, response& res, context& ctx);
+ auto return_bad_request = [&req, &res]() {
+ res.code = 400;
+ res.end();
+ };
+
+ auto return_internal_error = [&req, &res]() {
+ res.code = 500;
+ res.end();
+ };
+
+ if (req.url == "/" || boost::starts_with(req.url, "/static/")) {
+ // TODO this is total hackery to allow the login page to work before the
+ // user is authenticated. Also, it will be quite slow for all pages
+ // instead
+ // of a one time hit for the whitelist entries. Ideally, this should be
+ // done in the url router handler, with tagged routes for the whitelist
+ // entries. Another option would be to whitelist a minimal for based page
+ // that didn't
+ // load the full angular UI until after login
+ return;
+ }
+
+ if (req.url == "/login") {
+ if (req.method != HTTPMethod::POST) {
+ return_unauthorized();
+ return;
+ } else {
+ auto login_credentials = crow::json::load(req.body);
+ if (!login_credentials) {
+ return_bad_request();
+ return;
+ }
+ if (!login_credentials.has("username") ||
+ !login_credentials.has("password")) {
+ return_bad_request();
+ return;
+ }
+ auto username = login_credentials["username"].s();
+ auto password = login_credentials["password"].s();
+ auto p = AuthenticationFunction();
+ if (p.authenticate(username, password)) {
+ crow::json::wvalue x;
+
+ // TODO(ed) the RNG should be initialized at start, not every time we
+ // want a token
+ std::random_device rand;
+ random_bytes_engine rbe;
+ std::string token('a', 20);
+ // TODO(ed) for some reason clang-tidy finds a divide by zero error in
+ // cstdlibc here commented out for now. Needs investigation
+ std::generate(std::begin(token), std::end(token), std::ref(rbe)); // NOLINT
+ std::string encoded_token;
+ base64::base64_encode(token, encoded_token);
+ // ctx.auth_token = encoded_token;
+ this->auth_token2.insert(encoded_token);
+
+ x["token"] = encoded_token;
+
+ res.write(json::dump(x));
+ res.add_header("Content-Type", "application/json");
+ res.end();
+ } else {
+ return_unauthorized();
+ return;
+ }
+ }
+
+ } else { // Normal, non login, non static file request
+ // Check to make sure we're logged in
+ if (this->auth_token2.empty()) {
+ return_unauthorized();
+ return;
+ }
+ // Check for an authorization header, reject if not present
+ if (req.headers.count("Authorization") != 1) {
+ return_unauthorized();
+ return;
+ }
+
+ std::string auth_header = req.get_header_value("Authorization");
+ // If the user is attempting any kind of auth other than token, reject
+ if (!boost::starts_with(auth_header, "Token ")) {
+ return_unauthorized();
+ return;
+ }
+ std::string auth_key = auth_header.substr(6);
+ // TODO(ed), use span here instead of constructing a new string
+ if (this->auth_token2.find(auth_key) == this->auth_token2.end()) {
+ return_unauthorized();
+ return;
+ }
+
+ if (req.url == "/logout") {
+ this->auth_token2.erase(auth_key);
+ res.code = 200;
+ res.end();
+ return;
+ }
+
+ // else let the request continue unharmed
+ }
+ }
+
+ void after_handle(request& req, response& res, context& ctx) {
+ // Do nothing
+ }
private:
boost::container::flat_set<std::string> auth_token2;
};
+
+using TokenAuthorizationMiddleware = TokenAuthorization<PamAuthenticator>;
}
\ No newline at end of file
diff --git a/src/ast_video_puller_test.cpp b/src/ast_video_puller_test.cpp
index ef1cbe3..b1f94e7 100644
--- a/src/ast_video_puller_test.cpp
+++ b/src/ast_video_puller_test.cpp
@@ -14,7 +14,6 @@
#include <gtest/gtest.h>
TEST(AstvideoPuller, BasicRead) {
- std::cout << "Started\n";
AstVideo::RawVideoBuffer out;
bool have_hardware = false;
if (access("/dev/video", F_OK) != -1) {
@@ -43,7 +42,6 @@
fwrite(out.buffer.data(), sizeof(char), out.buffer.size(), fp);
AstVideo::AstJpegDecoder d;
- std::cout << "MODE " << static_cast<int>(out.mode);
d.decode(out.buffer, out.width, out.height, out.mode, out.y_selector,
out.uv_selector);
}
diff --git a/src/getvideo_main.cpp b/src/getvideo_main.cpp
index 33885ee..2ab0c0e 100644
--- a/src/getvideo_main.cpp
+++ b/src/getvideo_main.cpp
@@ -20,7 +20,6 @@
#include <ast_video_puller.hpp>
int main() {
- std::cout << "Started\n";
AstVideo::RawVideoBuffer out;
bool have_hardware = false;
if (access("/dev/video", F_OK) != -1) {
@@ -49,7 +48,6 @@
fwrite(out.buffer.data(), sizeof(char), out.buffer.size(), fp);
AstVideo::AstJpegDecoder d;
- std::cout << "MODE " << static_cast<int>(out.mode);
d.decode(out.buffer, out.width, out.height, out.mode, out.y_selector,
out.uv_selector);
#ifdef BUILD_CIMG
diff --git a/src/security_headers_middleware.cpp b/src/security_headers_middleware.cpp
deleted file mode 100644
index 265cda7..0000000
--- a/src/security_headers_middleware.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#include <security_headers_middleware.hpp>
-
-namespace crow {
-
-static const std::string strict_transport_security_key =
- "Strict-Transport-Security";
-static const std::string strict_transport_security_value =
- "max-age=31536000; includeSubdomains; preload";
-
-static const std::string ua_compatability_key = "X-UA-Compatible";
-static const std::string ua_compatability_value = "IE=11";
-
-static const std::string xframe_key = "X-Frame-Options";
-static const std::string xframe_value = "DENY";
-
-static const std::string xss_key = "X-XSS-Protection";
-static const std::string xss_value = "1; mode=block";
-
-static const std::string content_security_key = "X-Content-Security-Policy";
-static const std::string content_security_value = "default-src 'self'";
-
-void SecurityHeadersMiddleware::before_handle(crow::request& req, response& res,
- context& ctx) {}
-
-void SecurityHeadersMiddleware::after_handle(request& /*req*/, response& res,
- context& ctx) {
- /*
- TODO(ed) these should really check content types. for example,
- X-UA-Compatible header doesn't make sense when retrieving a JSON or
- javascript file. It doesn't hurt anything, it's just ugly.
- */
- res.add_header(strict_transport_security_key,
- strict_transport_security_value);
- res.add_header(ua_compatability_key, ua_compatability_value);
- res.add_header(xframe_key, xframe_value);
- res.add_header(xss_key, xss_value);
- res.add_header(content_security_key, content_security_value);
-}
-}
diff --git a/src/token_authorization_middleware.cpp b/src/token_authorization_middleware.cpp
deleted file mode 100644
index 508bfd9..0000000
--- a/src/token_authorization_middleware.cpp
+++ /dev/null
@@ -1,192 +0,0 @@
-#include <random>
-#include <unordered_map>
-#include <boost/algorithm/string/predicate.hpp>
-
-#include <security/pam_appl.h>
-#include <base64.hpp>
-#include <token_authorization_middleware.hpp>
-#include <crow/logging.h>
-
-namespace crow {
-
-using random_bytes_engine =
- std::independent_bits_engine<std::default_random_engine, CHAR_BIT,
- unsigned char>;
-
-// function used to get user input
-int pam_function_conversation(int num_msg, const struct pam_message** msg,
- struct pam_response** resp, void* appdata_ptr) {
- char* pass = (char*)malloc(strlen((char*)appdata_ptr) + 1);
- strcpy(pass, (char*)appdata_ptr);
-
- int i;
-
- *resp = (pam_response*)calloc(num_msg, sizeof(struct pam_response));
-
- for (i = 0; i < num_msg; ++i) {
- /* Ignore all PAM messages except prompting for hidden input */
- if (msg[i]->msg_style != PAM_PROMPT_ECHO_OFF) continue;
-
- /* Assume PAM is only prompting for the password as hidden input */
- resp[i]->resp = pass;
- }
-
- return PAM_SUCCESS;
-}
-
-bool authenticate_user_pam(const std::string& username,
- const std::string& password) {
- const struct pam_conv local_conversation = {pam_function_conversation,
- (char*)password.c_str()};
- pam_handle_t* local_auth_handle = NULL; // this gets set by pam_start
-
- int retval;
- retval = pam_start("su", username.c_str(), &local_conversation,
- &local_auth_handle);
-
- if (retval != PAM_SUCCESS) {
- printf("pam_start returned: %d\n ", retval);
- return false;
- }
-
- retval = pam_authenticate(local_auth_handle,
- PAM_SILENT | PAM_DISALLOW_NULL_AUTHTOK);
-
- if (retval != PAM_SUCCESS) {
- if (retval == PAM_AUTH_ERR) {
- printf("Authentication failure.\n");
- } else {
- printf("pam_authenticate returned %d\n", retval);
- }
- return false;
- }
-
- printf("Authenticated.\n");
- retval = pam_end(local_auth_handle, retval);
-
- if (retval != PAM_SUCCESS) {
- printf("pam_end returned\n");
- return false;
- }
-
- return true;
-}
-
-TokenAuthorizationMiddleware::TokenAuthorizationMiddleware(){
-};
-
-void TokenAuthorizationMiddleware::before_handle(crow::request& req,
- response& res, context& ctx) {
- auto return_unauthorized = [&req, &res]() {
- res.code = 401;
- res.end();
- };
-
- auto return_bad_request = [&req, &res]() {
- res.code = 400;
- res.end();
- };
-
- auto return_internal_error = [&req, &res]() {
- res.code = 500;
- res.end();
- };
-
- if (req.url == "/" || boost::starts_with(req.url, "/static/")) {
- // TODO this is total hackery to allow the login page to work before the
- // user is authenticated. Also, it will be quite slow for all pages instead
- // of a one time hit for the whitelist entries. Ideally, this should be
- // done in the url router handler, with tagged routes for the whitelist
- // entries. Another option would be to whitelist a minimal for based page
- // that didn't
- // load the full angular UI until after login
- return;
- }
-
- if (req.url == "/login") {
- if (req.method != HTTPMethod::POST) {
- return_unauthorized();
- return;
- } else {
- auto login_credentials = crow::json::load(req.body);
- if (!login_credentials) {
- return_bad_request();
- return;
- }
- if (!login_credentials.has("username") ||
- !login_credentials.has("password")) {
- return_bad_request();
- return;
- }
- auto username = login_credentials["username"].s();
- auto password = login_credentials["password"].s();
-
- // TODO(ed) pull real passwords from PAM
- if (authenticate_user_pam(username, password)) {
- crow::json::wvalue x;
-
- // TODO(ed) the RNG should be initialized at start, not every time we
- // want a token
- std::random_device rand;
- random_bytes_engine rbe;
- std::string token('a', 20);
- // TODO(ed) for some reason clang-tidy finds a divide by zero error in
- // cstdlibc here commented out for now. Needs investigation
- std::generate(begin(token), end(token), std::ref(rbe)); // NOLINT
- std::string encoded_token;
- base64::base64_encode(token, encoded_token);
- // ctx.auth_token = encoded_token;
- this->auth_token2.insert(encoded_token);
-
- x["token"] = encoded_token;
-
- res.write(json::dump(x));
- res.add_header("Content-Type", "application/json");
- res.end();
- } else {
- return_unauthorized();
- return;
- }
- }
-
- } else { // Normal, non login, non static file request
- // Check to make sure we're logged in
- if (this->auth_token2.empty()) {
- return_unauthorized();
- return;
- }
- // Check for an authorization header, reject if not present
- if (req.headers.count("Authorization") != 1) {
- return_unauthorized();
- return;
- }
-
- std::string auth_header = req.get_header_value("Authorization");
- // If the user is attempting any kind of auth other than token, reject
- if (!boost::starts_with(auth_header, "Token ")) {
- return_unauthorized();
- return;
- }
- std::string auth_key = auth_header.substr(6);
- // TODO(ed), use span here instead of constructing a new string
- if (this->auth_token2.find(auth_key) == this->auth_token2.end()) {
- return_unauthorized();
- return;
- }
-
- if (req.url == "/logout") {
- this->auth_token2.erase(auth_key);
- res.code = 200;
- res.end();
- return;
- }
-
- // else let the request continue unharmed
- }
-}
-
-void TokenAuthorizationMiddleware::after_handle(request& req, response& res,
- context& ctx) {
- // Do nothing
-}
-}
diff --git a/src/token_authorization_middleware_test.cpp b/src/token_authorization_middleware_test.cpp
index e8277653..49933c9 100644
--- a/src/token_authorization_middleware_test.cpp
+++ b/src/token_authorization_middleware_test.cpp
@@ -6,6 +6,14 @@
using namespace crow;
using namespace std;
+class KnownLoginAuthenticator {
+ public:
+ inline bool authenticate(const std::string& username,
+ const std::string& password) {
+ return (username == "dude") && (password == "foo");
+ }
+};
+
// Tests that static urls are correctly passed
TEST(TokenAuthentication, TestBasicReject) {
App<crow::TokenAuthorizationMiddleware> app;
@@ -177,9 +185,8 @@
app.stop();
}
-// Tests boundary conditions on login
TEST(TokenAuthentication, TestSuccessfulLogin) {
- App<crow::TokenAuthorizationMiddleware> app;
+ App<crow::TokenAuthorization<KnownLoginAuthenticator>> app;
app.bindaddr("127.0.0.1").port(45451);
CROW_ROUTE(app, "/")([]() { return 200; });
auto _ = async(launch::async, [&] { app.run(); });
@@ -215,7 +222,7 @@
// Test correct login credentials
sendmsg =
"POST /login\r\nContent-Length:40\r\n\r\n{\"username\": \"dude\", "
- "\"password\": \"dude\"}\r\n";
+ "\"password\": \"foo\"}\r\n";
{
send_to_localhost(sendmsg);
std::string response(std::begin(buf), std::end(buf));
diff --git a/src/webserver_main.cpp b/src/webserver_main.cpp
index 0c173dd..3baf388 100644
--- a/src/webserver_main.cpp
+++ b/src/webserver_main.cpp
@@ -246,9 +246,20 @@
return j;
});
- CROW_ROUTE(app, "/ipmiws")
+ CROW_ROUTE(app, "/sensorws")
.websocket()
.onopen([&](crow::websocket::connection& conn) {
+ dbus::connection system_bus(conn.get_io_service(), dbus::bus::system);
+ dbus::match ma(system_bus,
+ "type='signal',sender='org.freedesktop.DBus', "
+ "interface='org.freedesktop.DBus.Properties',member="
+ "'PropertiesChanged'");
+ dbus::filter f(system_bus, [](dbus::message& m) { return true; });
+
+ f.async_dispatch([&](boost::system::error_code ec, dbus::message s) {
+ std::cout << "got event\n";
+ //f.async_dispatch(event_handler);
+ });
})
.onclose(
@@ -257,57 +268,43 @@
})
.onmessage([&](crow::websocket::connection& conn, const std::string& data,
bool is_binary) {
- boost::asio::io_service io_service;
- using boost::asio::ip::udp;
- udp::resolver resolver(io_service);
- udp::resolver::query query(udp::v4(), "10.243.48.31", "623");
- udp::endpoint receiver_endpoint = *resolver.resolve(query);
-
- udp::socket socket(io_service);
- socket.open(udp::v4());
-
- socket.send_to(boost::asio::buffer(data), receiver_endpoint);
-
- std::array<char, 255> recv_buf;
-
- udp::endpoint sender_endpoint;
- size_t len =
- socket.receive_from(boost::asio::buffer(recv_buf), sender_endpoint);
- // TODO(ed) THis is ugly. Find a way to not make a copy (ie, use
- // std::string::data() to
- std::string str(std::begin(recv_buf), std::end(recv_buf));
- LOG(DEBUG) << "Got " << str << "back \n";
- conn.send_binary(str);
});
CROW_ROUTE(app, "/sensortest")
([](const crow::request& req, crow::response& res) {
+ crow::json::wvalue j;
+ auto values = read_sensor_values();
+
dbus::connection system_bus(*req.io_service, dbus::bus::system);
+ dbus::endpoint test_daemon("org.openbmc.Sensors",
+ "/org/openbmc/sensors/tach",
+ "org.freedesktop.DBus.Introspectable");
+ dbus::message m = dbus::message::new_call(test_daemon, "Introspect");
+ system_bus.async_send(
+ m,
+ [&j, &system_bus](const boost::system::error_code ec, dbus::message r) {
+ std::string xml;
+ r.unpack(xml);
+ std::vector<std::string> dbus_objects;
+ dbus::read_dbus_xml_names(xml, dbus_objects);
- dbus::endpoint test_daemon("org.freedesktop.DBus", "/",
- "org.freedesktop.DBus");
- dbus::message m = dbus::message::new_call(test_daemon, "ListNames");
- system_bus.async_send(m, [&](const boost::system::error_code ec,
- dbus::message r) {
- std::vector<std::string> services;
- //r.unpack(services);
- for (auto& service : services) {
- dbus::endpoint service_daemon(service, "/",
- "org.freedesktop.DBus.Introspectable");
- dbus::message m = dbus::message::new_call(service_daemon, "Introspect");
- system_bus.async_send(
- m, [&](const boost::system::error_code ec, dbus::message r) {
- std::string xml;
- r.unpack(xml);
- std::vector<std::string> dbus_objects;
- dbus::read_dbus_xml_names(xml, dbus_objects);
+ for (auto& object : dbus_objects) {
+ dbus::endpoint test_daemon("org.openbmc.Sensors",
+ "/org/openbmc/sensors/tach/" + object,
+ "org.openbmc.SensorValue");
+ dbus::message m2 = dbus::message::new_call(test_daemon, "getValue");
+
+ system_bus.async_send(
+ m2, [&](const boost::system::error_code ec, dbus::message r) {
+ int32_t value;
+ r.unpack(value);
+ // TODO(ed) if we ever go multithread, j needs a lock
+ j[object] = value;
+ });
+ }
-
- });
- }
-
- });
+ });
});
@@ -337,6 +334,6 @@
auto ssl_context = ensuressl::get_ssl_context(ssl_pem_file);
app.ssl(std::move(ssl_context));
}
- app.concurrency(4);
+ //app.concurrency(4);
app.run();
}