Unify logging (#60)

linaScience · web-flow · commit 323a448fe314 · 2023-07-18T14:29:06.000+02:00
diff --git a/src/BridgePerVxlanRenderer.cpp b/src/BridgePerVxlanRenderer.cpp
@@ -11,24 +11,24 @@ BridgePerVxlanRenderer::BridgePerVxlanRenderer()
 
 void BridgePerVxlanRenderer::setup_station(const Station& station) {
     std::lock_guard g(renderer_mutex);
-    WMLOG(DEBUG) << "Calling: setup_station(" << station << ")";
+    WMLOG(DEBUG) << "Calling setup_station station=" << station;
 
     uint32_t vni = station.vni();
     socket.create_vxlan_iface(vni);
     socket.create_bridge_for_vni(vni);
-    socket.add_iface_bridge("bridge" + std::to_string(vni), "vxlan" + std::to_string(vni));
 
     if (not station.vlan_id.has_value()) {
-        throw std::runtime_error("The station " + station.mac.string() + " has no vlan_id");
+        throw std::runtime_error("Station has no vlan_id station=" + station.mac.string());
     }
 
     socket.add_iface_bridge("bridge" + std::to_string(station.vni()), station.vlan_interface_name());
+    WMLOG(DEBUG) << "Finished bridge setup.";
 }
 
 void BridgePerVxlanRenderer::cleanup(const std::function<std::vector<Station>()>& get_stations) {
     std::lock_guard g(renderer_mutex);
     std::unordered_set<uint32_t> connected_station_vnis(0);
-    WMLOG(DEBUG) << "Starting cleanup.";
+    WMLOG(DEBUG) << "Started cleanup";
     int sta_counter = 0;
     for (auto& station : get_stations()) {
         connected_station_vnis.emplace(station.vni());
@@ -41,17 +41,17 @@ void BridgePerVxlanRenderer::cleanup(const std::function<std::vector<Station>()>
         existing_interfaces.erase(vni);
     }
     for (const auto vni : existing_interfaces) {
-        WMLOG(DEBUG) << "Deleting VNI " << vni;
+        WMLOG(DEBUG) << "Deleting vni=" << vni;
         try {
             socket.delete_interface("vxlan" + std::to_string(vni));
         } catch (const std::exception&) {
-            WMLOG(ERROR) << "Could not delete vxlan interface vni: " << vni;
+            WMLOG(ERROR) << "Could not delete vxlan vni=" << vni;
         }
         try {
             socket.delete_interface("bridge" + std::to_string(vni));
         } catch (const std::exception&) {
-            WMLOG(ERROR) << "Could not delete bridge vni: " << vni;
+            WMLOG(ERROR) << "Could not delete bridge vni=" << vni;
         }
     }
-    WMLOG(DEBUG) << "Cleanup finished, " << sta_counter << " stations connected.";
+    WMLOG(DEBUG) << "Cleanup finished. Connected stations: " << sta_counter;
 }
diff --git a/src/ConfigParser.cpp b/src/ConfigParser.cpp
@@ -28,7 +28,7 @@ ConfigParser ConfigParser::from_file(const std::string &config_path) {
     std::string line;
     std::ifstream config_file(config_path);
     if (!config_file.is_open()) {
-        WMLOG(ERROR) << "Unable to read config file " << config_path << ". Using default config";
+        WMLOG(ERROR) << "Using default configuartion because unable to read file config_path=" << config_path;
         return {};
     }
     return ConfigParser(config_file);
@@ -44,7 +44,7 @@ ConfigParser::ConfigParser(std::istream &istream) {
         }
         auto split = line.find(delimiter);
         if (split == std::string::npos) {
-            throw std::runtime_error("Configuration line is invalid: " + line);
+            throw std::runtime_error("Invalid configuration line=" + line);
         }
         std::string token = line.substr(0, split);
         trim(token);
@@ -60,7 +60,7 @@ ConfigParser::ConfigParser(std::istream &istream) {
 std::string ConfigParser::get_config_string(const std::string &option) const {
     auto got = config_options.find(option);
     if (got == config_options.end()) {
-        throw std::out_of_range(std::string("Could not get option: ") + option);
+        throw std::out_of_range(std::string("Could not get option=") + option);
     }
     return got->second;
 }
@@ -69,7 +69,8 @@ uint32_t ConfigParser::get_config_uint32(const std::string &option) const {
     std::string value = this->get_config_string(option);
     uint64_t result = std::stoull(value);
     if (result > std::numeric_limits<uint32_t>::max()) {
-        throw std::range_error("Number is too large for uint32_t. Config option " + option + " with value " + value);
+        throw std::range_error("Number is too large for uint32_t, therefore could not configure option=" + option +
+                               " value=" + value);
     }
     return result;
 }
diff --git a/src/Configuration.cpp b/src/Configuration.cpp
@@ -47,9 +47,9 @@ void Configuration::set_all_available_sockets_if_empty() {
             }
         }
         if (socknames.empty()) {
-            throw std::runtime_error("No sockets were configured and no sockets could be found.");
+            throw std::runtime_error("Could not configure sockets.");
         }
-        WMLOG(DEBUG) << "No sockets were configured. Using all " << socknames.size() << " sockets available.";
+        WMLOG(DEBUG) << "There were no sockets specified. Using all available sockets: " << socknames.size();
     }
 }
 
@@ -67,7 +67,7 @@ void Configuration::apply_environment() { set_all_available_sockets_if_empty();
 
 void Configuration::check_validity() const {
     if (min_vni > max_vni) {
-        throw std::runtime_error("min_vni must be less than or equal to max_vni " + std::to_string(min_vni) + " > " +
-                                 std::to_string(max_vni));
+        throw std::runtime_error("min_vni <= max_vni but min_vni=" + std::to_string(min_vni) +
+                                 " max_vni=" + std::to_string(max_vni));
     }
 }
diff --git a/src/EventLoop.cpp b/src/EventLoop.cpp
@@ -28,20 +28,21 @@ void EventLoop::loop_ipc_queue(const std::future<void>& future) {
 
 void EventLoop::handle_connect(ipc::ConnectEvent* event) {
     event->station.vlan_id = caller.vlan_for_station(event->station);
-    WMLOG(DEBUG) << "handle_connect called " << event->station << " with vlan_id "
-                 << event->station.vlan_id.value_or(0);
-    WMLOG(INFO) << "Station " << event->station << " connected to AP for VXLAN " << event->station.vni()
-                << " at interface " << event->station.sockname;
+    WMLOG(DEBUG) << "Entering handle_connect station=" << event->station
+                 << " vlan_id=" << event->station.vlan_id.value_or(0);
+    WMLOG(INFO) << "Connected iface=" << event->station.sockname << " station=" << event->station.mac.string()
+                << " vni=" << event->station.vni();
     try {
         renderer.setup_station(event->station);
         processing_time_histogram.Observe(static_cast<double>(event->finished_processing()));
     } catch (std::runtime_error& err) {
-        WMLOG(ERROR) << "station could not be bridged to vxlan interface: " << err.what()
-                     << " - Will now send deauth packet";
+        WMLOG(ERROR) << "Could not connect - Will now send DEAUTH packet. error=" << err.what()
+                     << " iface=" << event->station.sockname << " station=" << event->station.mac.string()
+                     << " vni=" << event->station.vni();
         caller.deauth_station(event->station);
     }
 }
 
 void EventLoop::handle_disconnect(ipc::DisconnectEvent* event) {
-    WMLOG(INFO) << "Station " << event->station << " disconnected from AP";
+    WMLOG(INFO) << "Disconnected station=" << event->station.mac.string();
 }
diff --git a/src/MacAddress.cpp b/src/MacAddress.cpp
@@ -8,7 +8,7 @@ const int BITS_PER_BYTE = 8;
 
 MacAddress::MacAddress(std::string serialized) : data(), serialized(serialized) {
     if (!std::regex_match(serialized, MAC_REGEX)) {
-        throw std::runtime_error("MAC address not valid");
+        throw std::runtime_error("Invalid station=" + serialized);
     }
     serialized.erase(std::remove(serialized.begin(), serialized.end(), ':'), serialized.end());
     for (size_t i = 0; i < MAC_NUM_BYTES; i++) {
diff --git a/src/ipc/Caller.cpp b/src/ipc/Caller.cpp
@@ -20,7 +20,7 @@ uint32_t ipc::Caller::vlan_for_station(const Station &station) {
             return std::stol(line.substr(VLAN_ID_PREFIX.size(), line.size()));
         }
     }
-    throw std::runtime_error("no vlan_id attribute found for station");
+    throw std::runtime_error("Could not find vlan_id station=" + station.mac.string());
 }
 
 std::vector<Station> ipc::Caller::connected_stations() {
diff --git a/src/ipc/Socket.cpp b/src/ipc/Socket.cpp
@@ -56,12 +56,12 @@ ipc::Socket::Socket(const std::chrono::duration<int>& timeout, const std::string
     std::string dest_path = Configuration::get_instance().hapd_sockdir + "/" + sockname;
     std::string local_path = "/var/run/wimoved." + random_name();
     if (unlink(local_path.c_str()) == 0) {
-        WMLOG(DEBUG) << "Successfully unlinked socket" << local_path;
+        WMLOG(DEBUG) << "Successfully unlinked socket local_path=" << local_path;
     }
 
     sock_fd = socket(AF_UNIX, SOCK_DGRAM, 0);
     if (sock_fd == -1) {
-        throw std::runtime_error(std::string("could not create socket: ") + std::strerror(errno));
+        throw std::runtime_error(std::string("Could not create socket error=") + std::strerror(errno));
     }
     auto timeout_usec = std::chrono::duration_cast<std::chrono::microseconds>(timeout);
     struct timeval tv {};
@@ -74,29 +74,31 @@ ipc::Socket::Socket(const std::chrono::duration<int>& timeout, const std::string
     local.sun_path[sizeof(local.sun_path) - 1] = '\0';
     if (bind(sock_fd, reinterpret_cast<struct sockaddr*>(&local), sizeof(local)) == -1) {
         close(sock_fd);
-        throw std::runtime_error("could not bind to socket " + dest_path + ": " + std::strerror(errno));
+        throw std::runtime_error(std::string("Could not bind to socket error=") + std::strerror(errno) +
+                                 std::string(" dest_path=") + dest_path);
     }
 
     std::array<char, GETGRNAM_BUFFER_SIZE> buf{};
     struct group grp {};
     struct group* grp_result = nullptr;
     getgrnam_r(Configuration::get_instance().hapd_group.c_str(), &grp, buf.data(), buf.size(), &grp_result);
     if (grp_result == nullptr) {
-        throw std::runtime_error(std::string("getgrnam failed: ") + std::strerror(errno));
+        throw std::runtime_error(std::string("Failed getgrnam_r() error=") + std::strerror(errno));
     }
     if (chown(local_path.c_str(), -1, grp_result->gr_gid) == -1) {
-        throw std::runtime_error(std::string("could not set socket group: ") + std::strerror(errno));
+        throw std::runtime_error(std::string("Could not set socket group error=") + std::strerror(errno));
     }
     if (chmod(local_path.c_str(), LOCAL_SOCKET_PERMISSIONS) == -1) {
-        throw std::runtime_error(std::string("could not set socket permissions: ") + std::strerror(errno));
+        throw std::runtime_error(std::string("Could not set socket permissions error=") + std::strerror(errno));
     }
 
     dest.sun_family = AF_UNIX;
     strncpy(dest.sun_path, dest_path.c_str(), sizeof(dest.sun_path));
     dest.sun_path[sizeof(dest.sun_path) - 1] = '\0';
     if (connect(sock_fd, reinterpret_cast<struct sockaddr*>(&dest), sizeof(dest)) == -1) {
         close(sock_fd);
-        throw std::runtime_error("could not connect to socket at " + dest_path + " : " + std::strerror(errno));
+        throw std::runtime_error(std::string("Could not connect to socket error=") + std::strerror(errno) +
+                                 std::string(" dest_path=") + dest_path);
     }
 }
 
@@ -105,10 +107,10 @@ ipc::Socket::~Socket() {
         return;
     }
     if (close(sock_fd) == -1) {
-        WMLOG(ERROR) << "Could not close socket: " << std::strerror(errno) << "\n";
+        WMLOG(ERROR) << "Could not close socket error=" << std::strerror(errno) << "\n";
     }
     if (unlink(local.sun_path) != 0) {
-        WMLOG(ERROR) << "Could not unlink socket: " << std::strerror(errno) << "\n";
+        WMLOG(ERROR) << "Could not unlink socket error=" << std::strerror(errno) << "\n";
     }
 }
 
@@ -118,7 +120,7 @@ void ipc::Socket::send_command(const std::vector<std::string>& args) {
 
     ssize_t err = send(sock_fd, command.c_str(), command.size(), 0);
     if (err < 0) {
-        throw std::runtime_error(std::string("could not send_command to socket: ") + std::strerror(errno));
+        throw std::runtime_error(std::string("Could not send to socket error=") + std::strerror(errno));
     }
 }
 
@@ -136,10 +138,10 @@ std::string ipc::Socket::receive() {
             return buf.substr(0, len);
         }
         if (errno == EAGAIN) {
-            throw TimeoutException("timeout in recv() from hostapd");
+            throw TimeoutException("Timeout from hostapd recv()");
         }
         if (errno != EINTR) {
-            throw std::runtime_error(std::string("could not recv from socket: ") + std::strerror(errno));
+            throw std::runtime_error(std::string("Could not receive from socket error=") + std::strerror(errno));
         }
     }
 }
diff --git a/src/ipc/Subscriber.cpp b/src/ipc/Subscriber.cpp
@@ -16,14 +16,14 @@ const std::string HOSTAPD_GLOBAL = "global";
 static std::pair<std::string, std::string> split_at_first_space(const std::string& line) {
     auto position = line.find(' ');
     if (position == std::string::npos) {
-        throw std::runtime_error("Could not parse event line: " + line);
+        throw std::runtime_error("Could not parse line=" + line);
     }
     return {line.substr(0, position), line.substr(position + 1)};
 }
 
 static std::string get_ifname(const std::string& eventprefix) {
     if (eventprefix.rfind(HOSTAPD_IFPREFIX) != 0) {
-        throw std::runtime_error("interface name could not be parsed from event prefix: " + eventprefix);
+        throw std::runtime_error("Could not parse eventprefix= " + eventprefix);
     }
     return eventprefix.substr(HOSTAPD_IFPREFIX.size());
 }
@@ -38,9 +38,9 @@ ipc::Subscriber::Subscriber(SynchronizedQueue<Event>& queue, const std::chrono::
 void ipc::Subscriber::loop(const std::future<void>& future) {
     std::string result = socket.send_and_receive({"ATTACH"});
     if (result != Socket::HOSTAPD_OK) {
-        throw std::runtime_error(std::string("could not attach to hostapd: ") + result);
+        throw std::runtime_error(std::string("Could not attach to hostapd error=") + result);
     }
-    WMLOG(INFO) << "attached to hostapd";
+    WMLOG(INFO) << "Attached to hostapd.";
     while (future.wait_for(std::chrono::seconds(0)) != std::future_status::ready) {
         std::string line;
         try {
@@ -49,7 +49,9 @@ void ipc::Subscriber::loop(const std::future<void>& future) {
             try {
                 line = socket.send_and_receive({"PING"});
             } catch (const TimeoutException& e) {
-                WMLOG(FATAL) << "timeout in Subscriber::loop_ipc_queue(), hostapd timed out while responding to ping";
+                WMLOG(FATAL)
+                    << "Timeout Subscriber::loop_ipc_queue(), hostapd timed out while responding to ping error="
+                    << e.what();
                 break;
             }
         }
@@ -64,7 +66,7 @@ void ipc::Subscriber::loop(const std::future<void>& future) {
 
         std::vector<std::string> interface_names = Configuration::get_instance().socknames;
         if (std::find(interface_names.begin(), interface_names.end(), sockname) == interface_names.end()) {
-            WMLOG(DEBUG) << "Received event on interface that is not configured " << sockname << ": " << event;
+            WMLOG(DEBUG) << "Not configured event=" << event << " iface=" << sockname;
             continue;
         }
 
@@ -76,7 +78,7 @@ void ipc::Subscriber::loop(const std::future<void>& future) {
                 queue.enqueue(std::make_unique<ConnectEvent>(std::move(station)));
                 hostapd_connect_counter.Increment();
             } catch (const std::runtime_error& e) {
-                WMLOG(ERROR) << "Unable to create event: " << e.what();
+                WMLOG(ERROR) << "Unable to create event error=" << e.what();
             }
         } else if (event.rfind(HOSTAPD_DISCONNECT_STRING) == 0) {
             MacAddress station_mac(
@@ -86,11 +88,11 @@ void ipc::Subscriber::loop(const std::future<void>& future) {
                 queue.enqueue(std::make_unique<DisconnectEvent>(std::move(station)));
                 hostapd_disconnect_counter.Increment();
             } catch (const std::runtime_error& e) {
-                WMLOG(ERROR) << "Unable to create event: " << e.what();
+                WMLOG(ERROR) << "Unable to create event error=" << e.what();
             }
         } else {
             hostapd_unknown_counter.Increment();
-            WMLOG(DEBUG) << "Received unknown event " << event;
+            WMLOG(DEBUG) << "Received unknown event=" << event;
         }
     }
 }
diff --git a/src/main.cpp b/src/main.cpp
@@ -36,9 +36,9 @@ void setup_logger() {
         } catch (const std::exception& ex) {
             WMLOG(FATAL) << typeid(ex).name() << ": " << ex.what();
         } catch (...) {
-            WMLOG(FATAL) << "Error while handling exception: " << typeid(std::current_exception()).name();
+            WMLOG(FATAL) << "Error while handling exception error=" << typeid(std::current_exception()).name();
         }
-        WMLOG(ERROR) << "errno: " << errno << ": " << std::strerror(errno) << std::endl;
+        WMLOG(ERROR) << "errno=" << errno << " error=" << std::strerror(errno) << std::endl;
         std::abort();
     });
     el::Configurations default_configuration;
@@ -62,12 +62,12 @@ int main(int argc, char* argv[]) {
     if (args.size() >= 2) {
         config_path = args[1];
     }
-    WMLOG(INFO) << "wimoved is starting";
+    WMLOG(INFO) << "Starting wimoved.";
     ConfigParser::from_file(config_path).populate_configuration(Configuration::get_instance());
     setup_logger();
 
     if (std::signal(SIGINT, handle_signal) == SIG_ERR || std::signal(SIGTERM, handle_signal) == SIG_ERR) {
-        WMLOG(FATAL) << "could not set up signal handlers " << std::strerror(errno);
+        WMLOG(FATAL) << "Could not set up signal handlers error=" << std::strerror(errno);
     }
 
     SynchronizedQueue<ipc::Event> ipc_queue;
diff --git a/src/nl/Socket.cpp b/src/nl/Socket.cpp

Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ ConfigParser ConfigParser::from_file(const std::string &config_path) {`
`28`	`28`	`std::string line;`
`29`	`29`	`std::ifstream config_file(config_path);`
`30`	`30`	`if (!config_file.is_open()) {`
`31`		`- WMLOG(ERROR) << "Unable to read config file " << config_path << ". Using default config";`
	`31`	`+ WMLOG(ERROR) << "Using default configuartion because unable to read file config_path=" << config_path;`
`32`	`32`	`return {};`
`33`	`33`	`}`
`34`	`34`	`return ConfigParser(config_file);`
`@@ -44,7 +44,7 @@ ConfigParser::ConfigParser(std::istream &istream) {`
`44`	`44`	`}`
`45`	`45`	`auto split = line.find(delimiter);`
`46`	`46`	`if (split == std::string::npos) {`
`47`		`- throw std::runtime_error("Configuration line is invalid: " + line);`
	`47`	`+ throw std::runtime_error("Invalid configuration line=" + line);`
`48`	`48`	`}`
`49`	`49`	`std::string token = line.substr(0, split);`
`50`	`50`	`trim(token);`
`@@ -60,7 +60,7 @@ ConfigParser::ConfigParser(std::istream &istream) {`
`60`	`60`	`std::string ConfigParser::get_config_string(const std::string &option) const {`
`61`	`61`	`auto got = config_options.find(option);`
`62`	`62`	`if (got == config_options.end()) {`
`63`		`- throw std::out_of_range(std::string("Could not get option: ") + option);`
	`63`	`+ throw std::out_of_range(std::string("Could not get option=") + option);`
`64`	`64`	`}`
`65`	`65`	`return got->second;`
`66`	`66`	`}`
`@@ -69,7 +69,8 @@ uint32_t ConfigParser::get_config_uint32(const std::string &option) const {`
`69`	`69`	`std::string value = this->get_config_string(option);`
`70`	`70`	`uint64_t result = std::stoull(value);`
`71`	`71`	`if (result > std::numeric_limits<uint32_t>::max()) {`
`72`		`- throw std::range_error("Number is too large for uint32_t. Config option " + option + " with value " + value);`
	`72`	`+ throw std::range_error("Number is too large for uint32_t, therefore could not configure option=" + option +`
	`73`	`+ " value=" + value);`
`73`	`74`	`}`
`74`	`75`	`return result;`
`75`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -47,9 +47,9 @@ void Configuration::set_all_available_sockets_if_empty() {`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`	`if (socknames.empty()) {`
`50`		`- throw std::runtime_error("No sockets were configured and no sockets could be found.");`
	`50`	`+ throw std::runtime_error("Could not configure sockets.");`
`51`	`51`	`}`
`52`		`- WMLOG(DEBUG) << "No sockets were configured. Using all " << socknames.size() << " sockets available.";`
	`52`	`+ WMLOG(DEBUG) << "There were no sockets specified. Using all available sockets: " << socknames.size();`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`
`@@ -67,7 +67,7 @@ void Configuration::apply_environment() { set_all_available_sockets_if_empty();`
`67`	`67`
`68`	`68`	`void Configuration::check_validity() const {`
`69`	`69`	`if (min_vni > max_vni) {`
`70`		`- throw std::runtime_error("min_vni must be less than or equal to max_vni " + std::to_string(min_vni) + " > " +`
`71`		`- std::to_string(max_vni));`
	`70`	`+ throw std::runtime_error("min_vni <= max_vni but min_vni=" + std::to_string(min_vni) +`
	`71`	`+ " max_vni=" + std::to_string(max_vni));`
`72`	`72`	`}`
`73`	`73`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ const int BITS_PER_BYTE = 8;`
`8`	`8`
`9`	`9`	`MacAddress::MacAddress(std::string serialized) : data(), serialized(serialized) {`
`10`	`10`	`if (!std::regex_match(serialized, MAC_REGEX)) {`
`11`		`- throw std::runtime_error("MAC address not valid");`
	`11`	`+ throw std::runtime_error("Invalid station=" + serialized);`
`12`	`12`	`}`
`13`	`13`	`serialized.erase(std::remove(serialized.begin(), serialized.end(), ':'), serialized.end());`
`14`	`14`	`for (size_t i = 0; i < MAC_NUM_BYTES; i++) {`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ uint32_t ipc::Caller::vlan_for_station(const Station &station) {`
`20`	`20`	`return std::stol(line.substr(VLAN_ID_PREFIX.size(), line.size()));`
`21`	`21`	`}`
`22`	`22`	`}`
`23`		`- throw std::runtime_error("no vlan_id attribute found for station");`
	`23`	`+ throw std::runtime_error("Could not find vlan_id station=" + station.mac.string());`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`std::vector<Station> ipc::Caller::connected_stations() {`
Original file line number	Diff line number	Diff line change
`@@ -56,12 +56,12 @@ ipc::Socket::Socket(const std::chrono::duration<int>& timeout, const std::string`
`56`	`56`	`std::string dest_path = Configuration::get_instance().hapd_sockdir + "/" + sockname;`
`57`	`57`	`std::string local_path = "/var/run/wimoved." + random_name();`
`58`	`58`	`if (unlink(local_path.c_str()) == 0) {`
`59`		`- WMLOG(DEBUG) << "Successfully unlinked socket" << local_path;`
	`59`	`+ WMLOG(DEBUG) << "Successfully unlinked socket local_path=" << local_path;`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`sock_fd = socket(AF_UNIX, SOCK_DGRAM, 0);`
`63`	`63`	`if (sock_fd == -1) {`
`64`		`- throw std::runtime_error(std::string("could not create socket: ") + std::strerror(errno));`
	`64`	`+ throw std::runtime_error(std::string("Could not create socket error=") + std::strerror(errno));`
`65`	`65`	`}`
`66`	`66`	`auto timeout_usec = std::chrono::duration_cast<std::chrono::microseconds>(timeout);`
`67`	`67`	`struct timeval tv {};`
`@@ -74,29 +74,31 @@ ipc::Socket::Socket(const std::chrono::duration<int>& timeout, const std::string`
`74`	`74`	`local.sun_path[sizeof(local.sun_path) - 1] = '\0';`
`75`	`75`	`if (bind(sock_fd, reinterpret_cast<struct sockaddr*>(&local), sizeof(local)) == -1) {`
`76`	`76`	`close(sock_fd);`
`77`		`- throw std::runtime_error("could not bind to socket " + dest_path + ": " + std::strerror(errno));`
	`77`	`+ throw std::runtime_error(std::string("Could not bind to socket error=") + std::strerror(errno) +`
	`78`	`+ std::string(" dest_path=") + dest_path);`
`78`	`79`	`}`
`79`	`80`
`80`	`81`	`std::array<char, GETGRNAM_BUFFER_SIZE> buf{};`
`81`	`82`	`struct group grp {};`
`82`	`83`	`struct group* grp_result = nullptr;`
`83`	`84`	`getgrnam_r(Configuration::get_instance().hapd_group.c_str(), &grp, buf.data(), buf.size(), &grp_result);`
`84`	`85`	`if (grp_result == nullptr) {`
`85`		`- throw std::runtime_error(std::string("getgrnam failed: ") + std::strerror(errno));`
	`86`	`+ throw std::runtime_error(std::string("Failed getgrnam_r() error=") + std::strerror(errno));`
`86`	`87`	`}`
`87`	`88`	`if (chown(local_path.c_str(), -1, grp_result->gr_gid) == -1) {`
`88`		`- throw std::runtime_error(std::string("could not set socket group: ") + std::strerror(errno));`
	`89`	`+ throw std::runtime_error(std::string("Could not set socket group error=") + std::strerror(errno));`
`89`	`90`	`}`
`90`	`91`	`if (chmod(local_path.c_str(), LOCAL_SOCKET_PERMISSIONS) == -1) {`
`91`		`- throw std::runtime_error(std::string("could not set socket permissions: ") + std::strerror(errno));`
	`92`	`+ throw std::runtime_error(std::string("Could not set socket permissions error=") + std::strerror(errno));`
`92`	`93`	`}`
`93`	`94`
`94`	`95`	`dest.sun_family = AF_UNIX;`
`95`	`96`	`strncpy(dest.sun_path, dest_path.c_str(), sizeof(dest.sun_path));`
`96`	`97`	`dest.sun_path[sizeof(dest.sun_path) - 1] = '\0';`
`97`	`98`	`if (connect(sock_fd, reinterpret_cast<struct sockaddr*>(&dest), sizeof(dest)) == -1) {`
`98`	`99`	`close(sock_fd);`
`99`		`- throw std::runtime_error("could not connect to socket at " + dest_path + " : " + std::strerror(errno));`
	`100`	`+ throw std::runtime_error(std::string("Could not connect to socket error=") + std::strerror(errno) +`
	`101`	`+ std::string(" dest_path=") + dest_path);`
`100`	`102`	`}`
`101`	`103`	`}`
`102`	`104`
`@@ -105,10 +107,10 @@ ipc::Socket::~Socket() {`
`105`	`107`	`return;`
`106`	`108`	`}`
`107`	`109`	`if (close(sock_fd) == -1) {`
`108`		`- WMLOG(ERROR) << "Could not close socket: " << std::strerror(errno) << "\n";`
	`110`	`+ WMLOG(ERROR) << "Could not close socket error=" << std::strerror(errno) << "\n";`
`109`	`111`	`}`
`110`	`112`	`if (unlink(local.sun_path) != 0) {`
`111`		`- WMLOG(ERROR) << "Could not unlink socket: " << std::strerror(errno) << "\n";`
	`113`	`+ WMLOG(ERROR) << "Could not unlink socket error=" << std::strerror(errno) << "\n";`
`112`	`114`	`}`
`113`	`115`	`}`
`114`	`116`
`@@ -118,7 +120,7 @@ void ipc::Socket::send_command(const std::vector<std::string>& args) {`
`118`	`120`
`119`	`121`	`ssize_t err = send(sock_fd, command.c_str(), command.size(), 0);`
`120`	`122`	`if (err < 0) {`
`121`		`- throw std::runtime_error(std::string("could not send_command to socket: ") + std::strerror(errno));`
	`123`	`+ throw std::runtime_error(std::string("Could not send to socket error=") + std::strerror(errno));`
`122`	`124`	`}`
`123`	`125`	`}`
`124`	`126`
`@@ -136,10 +138,10 @@ std::string ipc::Socket::receive() {`
`136`	`138`	`return buf.substr(0, len);`
`137`	`139`	`}`
`138`	`140`	`if (errno == EAGAIN) {`
`139`		`- throw TimeoutException("timeout in recv() from hostapd");`
	`141`	`+ throw TimeoutException("Timeout from hostapd recv()");`
`140`	`142`	`}`
`141`	`143`	`if (errno != EINTR) {`
`142`		`- throw std::runtime_error(std::string("could not recv from socket: ") + std::strerror(errno));`
	`144`	`+ throw std::runtime_error(std::string("Could not receive from socket error=") + std::strerror(errno));`
`143`	`145`	`}`
`144`	`146`	`}`
`145`	`147`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,14 +16,14 @@ const std::string HOSTAPD_GLOBAL = "global";`
`16`	`16`	`static std::pair<std::string, std::string> split_at_first_space(const std::string& line) {`
`17`	`17`	`auto position = line.find(' ');`
`18`	`18`	`if (position == std::string::npos) {`
`19`		`- throw std::runtime_error("Could not parse event line: " + line);`
	`19`	`+ throw std::runtime_error("Could not parse line=" + line);`
`20`	`20`	`}`
`21`	`21`	`return {line.substr(0, position), line.substr(position + 1)};`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`static std::string get_ifname(const std::string& eventprefix) {`
`25`	`25`	`if (eventprefix.rfind(HOSTAPD_IFPREFIX) != 0) {`
`26`		`- throw std::runtime_error("interface name could not be parsed from event prefix: " + eventprefix);`
	`26`	`+ throw std::runtime_error("Could not parse eventprefix= " + eventprefix);`
`27`	`27`	`}`
`28`	`28`	`return eventprefix.substr(HOSTAPD_IFPREFIX.size());`
`29`	`29`	`}`
`@@ -38,9 +38,9 @@ ipc::Subscriber::Subscriber(SynchronizedQueue<Event>& queue, const std::chrono::`
`38`	`38`	`void ipc::Subscriber::loop(const std::future<void>& future) {`
`39`	`39`	`std::string result = socket.send_and_receive({"ATTACH"});`
`40`	`40`	`if (result != Socket::HOSTAPD_OK) {`
`41`		`- throw std::runtime_error(std::string("could not attach to hostapd: ") + result);`
	`41`	`+ throw std::runtime_error(std::string("Could not attach to hostapd error=") + result);`
`42`	`42`	`}`
`43`		`- WMLOG(INFO) << "attached to hostapd";`
	`43`	`+ WMLOG(INFO) << "Attached to hostapd.";`
`44`	`44`	`while (future.wait_for(std::chrono::seconds(0)) != std::future_status::ready) {`
`45`	`45`	`std::string line;`
`46`	`46`	`try {`
`@@ -49,7 +49,9 @@ void ipc::Subscriber::loop(const std::future<void>& future) {`
`49`	`49`	`try {`
`50`	`50`	`line = socket.send_and_receive({"PING"});`
`51`	`51`	`} catch (const TimeoutException& e) {`
`52`		`- WMLOG(FATAL) << "timeout in Subscriber::loop_ipc_queue(), hostapd timed out while responding to ping";`
	`52`	`+ WMLOG(FATAL)`
	`53`	`+ << "Timeout Subscriber::loop_ipc_queue(), hostapd timed out while responding to ping error="`
	`54`	`+ << e.what();`
`53`	`55`	`break;`
`54`	`56`	`}`
`55`	`57`	`}`
`@@ -64,7 +66,7 @@ void ipc::Subscriber::loop(const std::future<void>& future) {`
`64`	`66`
`65`	`67`	`std::vector<std::string> interface_names = Configuration::get_instance().socknames;`
`66`	`68`	`if (std::find(interface_names.begin(), interface_names.end(), sockname) == interface_names.end()) {`
`67`		`- WMLOG(DEBUG) << "Received event on interface that is not configured " << sockname << ": " << event;`
	`69`	`+ WMLOG(DEBUG) << "Not configured event=" << event << " iface=" << sockname;`
`68`	`70`	`continue;`
`69`	`71`	`}`
`70`	`72`
`@@ -76,7 +78,7 @@ void ipc::Subscriber::loop(const std::future<void>& future) {`
`76`	`78`	`queue.enqueue(std::make_unique<ConnectEvent>(std::move(station)));`
`77`	`79`	`hostapd_connect_counter.Increment();`
`78`	`80`	`} catch (const std::runtime_error& e) {`
`79`		`- WMLOG(ERROR) << "Unable to create event: " << e.what();`
	`81`	`+ WMLOG(ERROR) << "Unable to create event error=" << e.what();`
`80`	`82`	`}`
`81`	`83`	`} else if (event.rfind(HOSTAPD_DISCONNECT_STRING) == 0) {`
`82`	`84`	`MacAddress station_mac(`
`@@ -86,11 +88,11 @@ void ipc::Subscriber::loop(const std::future<void>& future) {`
`86`	`88`	`queue.enqueue(std::make_unique<DisconnectEvent>(std::move(station)));`
`87`	`89`	`hostapd_disconnect_counter.Increment();`
`88`	`90`	`} catch (const std::runtime_error& e) {`
`89`		`- WMLOG(ERROR) << "Unable to create event: " << e.what();`
	`91`	`+ WMLOG(ERROR) << "Unable to create event error=" << e.what();`
`90`	`92`	`}`
`91`	`93`	`} else {`
`92`	`94`	`hostapd_unknown_counter.Increment();`
`93`		`- WMLOG(DEBUG) << "Received unknown event " << event;`
	`95`	`+ WMLOG(DEBUG) << "Received unknown event=" << event;`
`94`	`96`	`}`
`95`	`97`	`}`
`96`	`98`	`}`