Standardize and simplify mutexes

Remove attempt at tristate lock
Remove custom shared/timed mutex
Remove shared mutex use
Enforce timeouts via custom lock_guard and unique_lock
Start converting codebase to non-shared-mutex and standard locking
methods

adsb_icao.cc

@@ -104,7 +104,7 @@ void kis_adsb_icao::index() {
     z_off_t prev_pos;
     uint32_t last_icao = 0;
 
-    kis_lock_guard<kis_shared_mutex> lk(mutex, "adsb icao index");
+    kis_lock_guard<kis_mutex> lk(mutex, "adsb icao index");
 
     if (zmfile == nullptr)
         return;
@@ -167,7 +167,7 @@ std::shared_ptr<tracked_adsb_icao> kis_adsb_icao::lookup_icao(uint32_t icao) {
     }
 
     {
-        kis_shared_lock_guard<kis_shared_mutex> lk(mutex, "adsb icao lookup");
+        kis_lock_guard<kis_mutex> lk(mutex, "adsb icao lookup");
 
         auto cached = icao_map.find(icao);
         if (cached != icao_map.end())
@@ -192,7 +192,7 @@ std::shared_ptr<tracked_adsb_icao> kis_adsb_icao::lookup_icao(uint32_t icao) {
     }
 
     {
-        kis_lock_guard<kis_shared_mutex> lk(mutex, "adsb icao file lookup");
+        kis_lock_guard<kis_mutex> lk(mutex, "adsb icao file lookup");
 
         gzseek(zmfile, index_vec[matched].pos, SEEK_SET);
 

adsb_icao.h

@@ -143,7 +143,7 @@ class kis_adsb_icao {
     };
 
 protected:
-    kis_shared_mutex mutex;
+    kis_mutex mutex;
     std::map<char, std::shared_ptr<tracker_element_string>> atype_map;
 
     gzFile zmfile;

alertracker.cc

@@ -152,7 +152,7 @@ alert_tracker::alert_tracker() : lifetime_global() {
 }
 
 alert_tracker::~alert_tracker() {
-    kis_lock_guard<kis_shared_mutex> lk(alert_mutex, "~alertracker");
+    kis_lock_guard<kis_mutex> lk(alert_mutex, "~alertracker");
 
     Globalreg::globalreg->remove_global("ALERTTRACKER");
     Globalreg::globalreg->alertracker = NULL;
@@ -190,7 +190,7 @@ void alert_tracker::prelude_init_client(const char *analyzer_name) {
 int alert_tracker::register_alert(std::string in_header, std::string in_description, 
         alert_time_unit in_unit, int in_rate, alert_time_unit in_burstunit,
         int in_burst, int in_phy) {
-    kis_lock_guard<kis_shared_mutex> lk(alert_mutex, "alert_tracker register_alert");
+    kis_lock_guard<kis_mutex> lk(alert_mutex, "alert_tracker register_alert");
 
     // Bail if this header is registered
     if (alert_name_map.find(in_header) != alert_name_map.end()) {
@@ -234,7 +234,7 @@ int alert_tracker::register_alert(std::string in_header, std::string in_descript
 }
 
 int alert_tracker::fetch_alert_ref(std::string in_header) {
-    kis_lock_guard<kis_shared_mutex> lk(alert_mutex, "alert_tracker fetch_alert_ref");
+    kis_lock_guard<kis_mutex> lk(alert_mutex, "alert_tracker fetch_alert_ref");
 
     auto ni = alert_name_map.find(in_header);
 
@@ -278,7 +278,7 @@ int alert_tracker::check_times(shared_alert_def arec) {
 }
 
 int alert_tracker::potential_alert(int in_ref) {
-    kis_lock_guard<kis_shared_mutex> lk(alert_mutex, "alert_tracker potential_alert");
+    kis_lock_guard<kis_mutex> lk(alert_mutex, "alert_tracker potential_alert");
 
     std::map<int, shared_alert_def>::iterator aritr = alert_ref_map.find(in_ref);
 
@@ -294,7 +294,7 @@ int alert_tracker::raise_alert(int in_ref, kis_packet *in_pack,
         mac_addr bssid, mac_addr source, mac_addr dest, 
         mac_addr other, std::string in_channel, std::string in_text) {
 
-    kis_unique_lock<kis_shared_mutex> lock(alert_mutex, std::defer_lock, "alert_tracker raise_alert");
+    kis_unique_lock<kis_mutex> lock(alert_mutex, std::defer_lock, "alert_tracker raise_alert");
 
     lock.lock();
 
@@ -378,7 +378,7 @@ int alert_tracker::raise_alert(int in_ref, kis_packet *in_pack,
 }
 
 int alert_tracker::raise_one_shot(std::string in_header, std::string in_text, int in_phy) {
-    kis_unique_lock<kis_shared_mutex> lock(alert_mutex, std::defer_lock, "alert_tracker raise_one_shot");
+    kis_unique_lock<kis_mutex> lock(alert_mutex, std::defer_lock, "alert_tracker raise_one_shot");
 
 	kis_alert_info info;
 
@@ -577,7 +577,7 @@ int alert_tracker::parse_alert_config(config_file *in_conf) {
 
 int alert_tracker::define_alert(std::string name, alert_time_unit limit_unit, int limit_rate,
         alert_time_unit burst_unit, int burst_rate) {
-    kis_lock_guard<kis_shared_mutex> lk(alert_mutex, "alert_tracker define_alert");
+    kis_lock_guard<kis_mutex> lk(alert_mutex, "alert_tracker define_alert");
 
     auto ai = alert_conf_map.find(str_upper(name));
     if (ai != alert_conf_map.end()) {
@@ -605,7 +605,7 @@ int alert_tracker::activate_configured_alert(std::string in_header, std::string
     alert_conf_rec *rec;
 
     {
-        kis_lock_guard<kis_shared_mutex> lk(alert_mutex, "alert_tracker activate_configured_alert");
+        kis_lock_guard<kis_mutex> lk(alert_mutex, "alert_tracker activate_configured_alert");
 
         std::string hdr = str_upper(in_header);
 
@@ -632,7 +632,7 @@ int alert_tracker::activate_configured_alert(std::string in_header, std::string
 }
 
 int alert_tracker::find_activated_alert(std::string in_header) {
-    kis_lock_guard<kis_shared_mutex> lk(alert_mutex, "alert_tracker find_activated_alert");
+    kis_lock_guard<kis_mutex> lk(alert_mutex, "alert_tracker find_activated_alert");
 
     for (auto x : alert_ref_map) {
         if (x.second->get_header() == in_header)
@@ -673,7 +673,7 @@ alert_tracker::last_alerts_endpoint(std::shared_ptr<kis_net_beast_httpd_connecti
     }
 
     {
-        kis_lock_guard<kis_shared_mutex> lk(alert_mutex, "alert_tracker last_alerts_endpoint");
+        kis_lock_guard<kis_mutex> lk(alert_mutex, "alert_tracker last_alerts_endpoint");
 
         for (auto i : *alert_backlog_vec) {
             auto ai = std::static_pointer_cast<tracked_alert>(i);

alertracker.h

@@ -418,7 +418,7 @@ class alert_tracker : public lifetime_global {
     }
 
 protected:
-    kis_shared_mutex alert_mutex;
+    kis_mutex alert_mutex;
 
     std::shared_ptr<packet_chain> packetchain;
     std::shared_ptr<entry_tracker> entrytracker;

antennatracker.cc

@@ -38,7 +38,7 @@ Antennatracker::~Antennatracker() {
 }
 
 int Antennatracker::add_antenna(uuid in_src, int in_srcnum, int in_adjustment) {
-    kis_lock_guard<kis_shared_mutex> lk(mutex, "antenna add_antenna");
+    kis_lock_guard<kis_mutex> lk(mutex, "antenna add_antenna");
 
     for (auto ai : *antenna_id_map) {
         auto a = std::static_pointer_cast<tracked_antenna>(ai.second);
@@ -66,7 +66,7 @@ int Antennatracker::add_antenna(uuid in_src, int in_srcnum, int in_adjustment) {
 }
 
 int Antennatracker::add_antenna(uuid in_src, int in_srcnum, int in_adjustment, uuid in_ant_uuid) {
-    kis_lock_guard<kis_shared_mutex> lk(mutex, "antennatracker add_antenna");
+    kis_lock_guard<kis_mutex> lk(mutex, "antennatracker add_antenna");
 
     for (auto ai : *antenna_id_map) {
         auto a = std::static_pointer_cast<tracked_antenna>(ai.second);
@@ -90,7 +90,7 @@ int Antennatracker::add_antenna(uuid in_src, int in_srcnum, int in_adjustment, u
 }
 
 int Antennatracker::set_antenna_adjustment(int in_antnum, int in_adjustment) {
-    kis_lock_guard<kis_shared_mutex> lk(mutex, "antennatracker set_antenna_adjustment");
+    kis_lock_guard<kis_mutex> lk(mutex, "antennatracker set_antenna_adjustment");
 
     auto ai = antenna_id_map->find(in_antnum);
 
@@ -104,7 +104,7 @@ int Antennatracker::set_antenna_adjustment(int in_antnum, int in_adjustment) {
 }
 
 std::shared_ptr<tracked_antenna> Antennatracker::get_antenna(int in_antnum) {
-    kis_lock_guard<kis_shared_mutex> lk(mutex, "antennatracker get_antenna");
+    kis_lock_guard<kis_mutex> lk(mutex, "antennatracker get_antenna");
 
     auto ai = antenna_id_map->find(in_antnum);
 

antennatracker.h

@@ -126,7 +126,7 @@ class Antennatracker : public lifetime_global {
     std::shared_ptr<tracked_antenna> get_antenna(int in_antnum);
 
 protected:
-    kis_shared_mutex mutex;
+    kis_mutex mutex;
 
     int next_ant_id;
 

bluetooth_ids.cc

@@ -91,7 +91,7 @@ void kis_bt_oid::index_bt_oids() {
     if (zofile == nullptr)
         return;
 
-    kis_lock_guard<kis_shared_mutex> lk(mutex, "kis_btoit index_bt_oids");
+    kis_lock_guard<kis_mutex> lk(mutex, "kis_btoit index_bt_oids");
 
     _MSG_INFO("Indexing Bluetooth OID list");
 
@@ -131,7 +131,7 @@ std::shared_ptr<tracker_element_string> kis_bt_oid::lookup_oid(uint32_t in_oid)
     if (zofile == nullptr)
         return unknown_oid;
 
-    kis_lock_guard<kis_shared_mutex> lk(mutex, "kis_bt_oit lookup_oid");
+    kis_lock_guard<kis_mutex> lk(mutex, "kis_bt_oit lookup_oid");
 
     if (oid_map.find(in_oid) != oid_map.end())
         return oid_map[in_oid].data;
@@ -271,7 +271,7 @@ void kis_bt_manuf::index_bt_manufs() {
     if (zmfile == nullptr)
         return;
 
-    kis_lock_guard<kis_shared_mutex> lk(mutex, "kis_bt_manuf index_bt_manufs");
+    kis_lock_guard<kis_mutex> lk(mutex, "kis_bt_manuf index_bt_manufs");
 
     _MSG_INFO("Indexing Bluetooth manufacturer list");
 
@@ -311,7 +311,7 @@ std::shared_ptr<tracker_element_string> kis_bt_manuf::lookup_manuf(uint32_t in_i
     if (zmfile == nullptr)
         return unknown_manuf;
 
-    kis_lock_guard<kis_shared_mutex> lk(mutex, "kis_bt_manuf lookup_manuf");
+    kis_lock_guard<kis_mutex> lk(mutex, "kis_bt_manuf lookup_manuf");
 
     if (manuf_map.find(in_id) != manuf_map.end())
         return manuf_map[in_id].manuf;

bluetooth_ids.h

@@ -64,7 +64,7 @@ class kis_bt_oid : public lifetime_global {
     bool is_unknown_oid(std::shared_ptr<tracker_element_string> in_oid);
 
 protected:
-    kis_shared_mutex mutex;
+    kis_mutex mutex;
 
     std::vector<index_pos> index_vec;
 
@@ -109,7 +109,7 @@ class kis_bt_manuf : public lifetime_global {
     bool is_unknown_manuf(std::shared_ptr<tracker_element_string> in_manuf);
 
 protected:
-    kis_shared_mutex mutex;
+    kis_mutex mutex;
 
     std::vector<index_pos> index_vec;
 

channeltracker2.cc

@@ -89,7 +89,7 @@ channel_tracker_v2::channel_tracker_v2(global_registry *in_globalreg) :
 }
 
 channel_tracker_v2::~channel_tracker_v2() {
-    kis_lock_guard<kis_shared_mutex> lk(lock, "~channel_tracker_v2");
+    kis_lock_guard<kis_mutex> lk(lock, "~channel_tracker_v2");
 
     auto timetracker = Globalreg::fetch_global_as<time_tracker>("TIMETRACKER");
     if (timetracker != nullptr)
@@ -155,7 +155,7 @@ int channel_tracker_v2::gather_devices_event(int event_id __attribute__((unused)
 }
 
 void channel_tracker_v2::update_device_counts(std::unordered_map<double, unsigned int> in_counts, time_t ts) {
-    kis_lock_guard<kis_shared_mutex> lk(lock, "channel_tracker_v2 update_device_counts");
+    kis_lock_guard<kis_mutex> lk(lock, "channel_tracker_v2 update_device_counts");
 
     for (auto i : in_counts) {
         auto imi = frequency_map->find(i.first);
@@ -180,7 +180,7 @@ void channel_tracker_v2::update_device_counts(std::unordered_map<double, unsigne
 int channel_tracker_v2::packet_chain_handler(CHAINCALL_PARMS) {
     channel_tracker_v2 *cv2 = (channel_tracker_v2 *) auxdata;
 
-    kis_lock_guard<kis_shared_mutex> lk(cv2->lock, "channel_tracker_v2 packet_chain_handler");
+    kis_lock_guard<kis_mutex> lk(cv2->lock, "channel_tracker_v2 packet_chain_handler");
 
     auto l1info = in_pack->fetch<kis_layer1_packinfo>(cv2->pack_comp_l1data);
 	auto common = in_pack->fetch<kis_common_info>(cv2->pack_comp_common);

channeltracker2.h

@@ -165,7 +165,7 @@ class channel_tracker_v2 : public lifetime_global {
     void update_device_counts(std::unordered_map<double, unsigned int> in_counts, time_t in_ts);
 
 protected:
-    kis_shared_mutex lock;
+    kis_mutex lock;
 
     std::shared_ptr<device_tracker> devicetracker;
     std::shared_ptr<time_tracker> timetracker;

class_filter.cc

@@ -150,7 +150,7 @@ class_filter_mac_addr::~class_filter_mac_addr() {
 }
 
 void class_filter_mac_addr::set_filter(mac_addr in_mac, const std::string& in_phy, bool value) {
-    kis_lock_guard<kis_shared_mutex> lk(mutex, "class_filter_mac_addr set_filter");
+    kis_lock_guard<kis_mutex> lk(mutex, "class_filter_mac_addr set_filter");
 
     // Build the tracked version of the record, building any containers we need along the way, this
     // always gets built even for unknown phys
@@ -188,7 +188,7 @@ void class_filter_mac_addr::set_filter(mac_addr in_mac, const std::string& in_ph
 }
 
 void class_filter_mac_addr::remove_filter(mac_addr in_mac, const std::string& in_phy) {
-    kis_lock_guard<kis_shared_mutex> lk(mutex, "class_filter_mac_addr remove_filter");
+    kis_lock_guard<kis_mutex> lk(mutex, "class_filter_mac_addr remove_filter");
 
     // Remove it from the tracked version we display
     auto tracked_phy_key = filter_phy_block->find(in_phy);
@@ -229,7 +229,7 @@ void class_filter_mac_addr::remove_filter(mac_addr in_mac, const std::string& in
 }
 
 void class_filter_mac_addr::update_phy_map(std::shared_ptr<eventbus_event> evt) {
-    kis_lock_guard<kis_shared_mutex> lk(mutex, "class_filter_mac_addr update_phy_map");
+    kis_lock_guard<kis_mutex> lk(mutex, "class_filter_mac_addr update_phy_map");
 
     if (unknown_phy_mac_filter_map.size() == 0)
         return;
@@ -329,7 +329,7 @@ void class_filter_mac_addr::remove_endp_handler(std::shared_ptr<kis_net_beast_ht
 }
 
 bool class_filter_mac_addr::filter(mac_addr mac, unsigned int phy) {
-    kis_lock_guard<kis_shared_mutex> lk(mutex, "class_filter_mac_addr filter");
+    kis_lock_guard<kis_mutex> lk(mutex, "class_filter_mac_addr filter");
 
     auto pi = phy_mac_filter_map.find(phy);
 

class_filter.h

@@ -61,7 +61,7 @@ class class_filter : public tracker_component {
         register_field("kismet.classfilter.default", "Default filter (pass/reject)", &filter_default);
     }
 
-    kis_shared_mutex mutex;
+    kis_mutex mutex;
 
     std::string base_uri;