Skip to content

Commit

Permalink
Merge remote-tracking branch 'og/master'
Browse files Browse the repository at this point in the history
  • Loading branch information
sketchybinary committed Aug 15, 2019
2 parents 6ef98cc + e799ab1 commit 591d9cb
Show file tree
Hide file tree
Showing 218 changed files with 9,921 additions and 10,509 deletions.
2 changes: 1 addition & 1 deletion Makefile.in
View file
Original file line number Diff line number Diff line change
Expand Up @@ -175,7 +175,7 @@ PSO = util.cc.o macaddr.cc.o uuid.cc.o xxhash.cc.o boost_like_hash.cc.o sqlite3_
pollabletracker.cc.o ringbuf2.cc.o chainbuf.cc.o filewritebuf.cc.o buffer_handler.cc.o \
packet.cc.o messagebus.cc.o configfile.cc.o getopt.cc.o \
psutils.cc.o battery.cc.o \
tcpserver2.cc.o tcpclient2.cc.o serialclient2.cc.o pipeclient.cc.o ipc_remote2.cc.o \
tcpserver2.cc.o tcpclient2.cc.o serialclient2.cc.o pipeclient.cc.o socketclient.cc.o ipc_remote2.cc.o \
$(PROTOBUF_CPP_O_TARGET) kis_external.cc.o \
dlttracker.cc.o antennatracker.cc.o datasourcetracker.cc.o kis_datasource.cc.o \
datasource_linux_bluetooth.cc.o datasource_rtl433.cc.o datasource_rtlamr.cc.o datasource_rtladsb.cc.o \
Expand Down
224 changes: 112 additions & 112 deletions alertracker.cc
View file

Large diffs are not rendered by default.

164 changes: 82 additions & 82 deletions alertracker.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,7 +7,7 @@
(at your option) any later version.
Kismet is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
Expand Down Expand Up @@ -109,23 +109,23 @@ class tracked_alert : public tracker_component {
reserve_fields(NULL);
}

tracked_alert(int in_id, std::shared_ptr<TrackerElementMap> e) :
tracked_alert(int in_id, std::shared_ptr<tracker_element_map> e) :
tracker_component(in_id) {
register_fields();
reserve_fields(e);
}

virtual uint32_t get_signature() const override {
return Adler32Checksum("tracked_alert");
return adler32_checksum("tracked_alert");
}

virtual std::unique_ptr<TrackerElement> clone_type() override {
virtual std::unique_ptr<tracker_element> clone_type() override {
using this_t = std::remove_pointer<decltype(this)>::type;
auto dup = std::unique_ptr<this_t>(new this_t());
return std::move(dup);
}

virtual std::unique_ptr<TrackerElement> clone_type(int in_id) override {
virtual std::unique_ptr<tracker_element> clone_type(int in_id) override {
using this_t = std::remove_pointer<decltype(this)>::type;
auto dup = std::unique_ptr<this_t>(new this_t(in_id));
return std::move(dup);
Expand Down Expand Up @@ -169,31 +169,31 @@ class tracked_alert : public tracker_component {
virtual void register_fields() override {
tracker_component::register_fields();

RegisterField("kismet.alert.device_key", "Device key of linked device", &devicekey);
RegisterField("kismet.alert.header", "Alert type", &header);
RegisterField("kismet.alert.phy_id", "ID of phy generating alert", &phy);
RegisterField("kismet.alert.timestamp", "Timestamp (sec.ms)", &timestamp);
RegisterField("kismet.alert.transmitter_mac", "Transmitter MAC address", &transmitter_mac);
RegisterField("kismet.alert.source_mac", "Source MAC address", &source_mac);
RegisterField("kismet.alert.dest_mac", "Destination MAC address", &dest_mac);
RegisterField("kismet.alert.other_mac", "Other / Extra MAC address", &other_mac);
RegisterField("kismet.alert.channel", "Phy-specific channel", &channel);
RegisterField("kismet.alert.frequency", "Frequency (khz)", &frequency);
RegisterField("kismet.alert.text", "Alert text", &text);
RegisterField("kismet.alert.location", "location", &location);
register_field("kismet.alert.device_key", "Device key of linked device", &devicekey);
register_field("kismet.alert.header", "Alert type", &header);
register_field("kismet.alert.phy_id", "ID of phy generating alert", &phy);
register_field("kismet.alert.timestamp", "Timestamp (sec.ms)", &timestamp);
register_field("kismet.alert.transmitter_mac", "Transmitter MAC address", &transmitter_mac);
register_field("kismet.alert.source_mac", "Source MAC address", &source_mac);
register_field("kismet.alert.dest_mac", "Destination MAC address", &dest_mac);
register_field("kismet.alert.other_mac", "Other / Extra MAC address", &other_mac);
register_field("kismet.alert.channel", "Phy-specific channel", &channel);
register_field("kismet.alert.frequency", "Frequency (khz)", &frequency);
register_field("kismet.alert.text", "Alert text", &text);
register_field("kismet.alert.location", "location", &location);
}

std::shared_ptr<TrackerElementDeviceKey> devicekey;
std::shared_ptr<TrackerElementString> header;
std::shared_ptr<TrackerElementUInt32> phy;
std::shared_ptr<TrackerElementDouble> timestamp;
std::shared_ptr<TrackerElementMacAddr> transmitter_mac;
std::shared_ptr<TrackerElementMacAddr> source_mac;
std::shared_ptr<TrackerElementMacAddr> dest_mac;
std::shared_ptr<TrackerElementMacAddr> other_mac;
std::shared_ptr<TrackerElementString> channel;
std::shared_ptr<TrackerElementDouble> frequency;
std::shared_ptr<TrackerElementString> text;
std::shared_ptr<tracker_element_device_key> devicekey;
std::shared_ptr<tracker_element_string> header;
std::shared_ptr<tracker_element_uint32> phy;
std::shared_ptr<tracker_element_double> timestamp;
std::shared_ptr<tracker_element_mac_addr> transmitter_mac;
std::shared_ptr<tracker_element_mac_addr> source_mac;
std::shared_ptr<tracker_element_mac_addr> dest_mac;
std::shared_ptr<tracker_element_mac_addr> other_mac;
std::shared_ptr<tracker_element_string> channel;
std::shared_ptr<tracker_element_double> frequency;
std::shared_ptr<tracker_element_string> text;
std::shared_ptr<kis_tracked_location_triplet> location;
};

Expand All @@ -220,23 +220,23 @@ class tracked_alert_definition : public tracker_component {
reserve_fields(NULL);
}

tracked_alert_definition(int in_id, std::shared_ptr<TrackerElementMap> e) :
tracked_alert_definition(int in_id, std::shared_ptr<tracker_element_map> e) :
tracker_component(in_id) {
register_fields();
reserve_fields(e);
}

virtual uint32_t get_signature() const override {
return Adler32Checksum("tracked_alert_definition");
return adler32_checksum("tracked_alert_definition");
}

virtual std::unique_ptr<TrackerElement> clone_type() override {
virtual std::unique_ptr<tracker_element> clone_type() override {
using this_t = std::remove_pointer<decltype(this)>::type;
auto dup = std::unique_ptr<this_t>(new this_t());
return std::move(dup);
}

virtual std::unique_ptr<TrackerElement> clone_type(int in_id) override {
virtual std::unique_ptr<tracker_element> clone_type(int in_id) override {
using this_t = std::remove_pointer<decltype(this)>::type;
auto dup = std::unique_ptr<this_t>(new this_t(in_id));
return std::move(dup);
Expand Down Expand Up @@ -267,48 +267,48 @@ class tracked_alert_definition : public tracker_component {
virtual void register_fields() override {
tracker_component::register_fields();

RegisterField("kismet.alert.definition.header", "Alert type", &header);
RegisterField("kismet.alert.definition.description", "Alert description", &description);
RegisterField("kismet.alert.definition.phyid", "Alert phy type", &phy);
RegisterField("kismet.alert.definition.limit_unit",
register_field("kismet.alert.definition.header", "Alert type", &header);
register_field("kismet.alert.definition.description", "Alert description", &description);
register_field("kismet.alert.definition.phyid", "Alert phy type", &phy);
register_field("kismet.alert.definition.limit_unit",
"Alert limit time unit (defined in alertracker.h)", &limit_unit);
RegisterField("kismet.alert.definition.limit_rate", "Alert rate limit", &limit_rate);
RegisterField("kismet.alert.definition.burst_unit",
register_field("kismet.alert.definition.limit_rate", "Alert rate limit", &limit_rate);
register_field("kismet.alert.definition.burst_unit",
"Burst limit time unit (defined in alertracker.h)", &burst_unit);
RegisterField("kismet.alert.definition.limit_burst", "Burst rate limit", &limit_burst);
RegisterField("kismet.alert.definition.burst_sent", "Alerts sent in burst", &burst_sent);
RegisterField("kismet.alert.definition.total_sent", "Total alerts sent", &total_sent);
RegisterField("kismet.alert.definition.time_last",
register_field("kismet.alert.definition.limit_burst", "Burst rate limit", &limit_burst);
register_field("kismet.alert.definition.burst_sent", "Alerts sent in burst", &burst_sent);
register_field("kismet.alert.definition.total_sent", "Total alerts sent", &total_sent);
register_field("kismet.alert.definition.time_last",
"Timestamp of last alert (sec.us)", &time_last);
}

// Non-exposed internal reference
int alert_ref;

// Alert type and description
std::shared_ptr<TrackerElementString> header;
std::shared_ptr<TrackerElementString> description;
std::shared_ptr<tracker_element_string> header;
std::shared_ptr<tracker_element_string> description;
// Phynum this is linked to
std::shared_ptr<TrackerElementInt64> phy;
std::shared_ptr<tracker_element_int64> phy;

// Units, rate limit, burst, and burst rate
std::shared_ptr<TrackerElementUInt64> limit_unit;
std::shared_ptr<TrackerElementUInt64> limit_rate;
std::shared_ptr<TrackerElementUInt64> burst_unit;
std::shared_ptr<TrackerElementUInt64> limit_burst;
std::shared_ptr<tracker_element_uint64> limit_unit;
std::shared_ptr<tracker_element_uint64> limit_rate;
std::shared_ptr<tracker_element_uint64> burst_unit;
std::shared_ptr<tracker_element_uint64> limit_burst;

// Number of burst and total alerts we've sent of this type
std::shared_ptr<TrackerElementUInt64> burst_sent;
std::shared_ptr<TrackerElementUInt64> total_sent;
std::shared_ptr<tracker_element_uint64> burst_sent;
std::shared_ptr<tracker_element_uint64> total_sent;

// Timestamp of the last time
std::shared_ptr<TrackerElementDouble> time_last;
std::shared_ptr<tracker_element_double> time_last;

};

typedef std::shared_ptr<tracked_alert_definition> shared_alert_def;

class Alertracker : public Kis_Net_Httpd_CPPStream_Handler, public LifetimeGlobal {
class alert_tracker : public kis_net_httpd_cppstream_handler, public lifetime_global {
public:
// Simple struct from reading config lines
struct alert_conf_rec {
Expand All @@ -321,88 +321,88 @@ class Alertracker : public Kis_Net_Httpd_CPPStream_Handler, public LifetimeGloba

static std::string global_name() { return "ALERTTRACKER"; }

static std::shared_ptr<Alertracker> create_alertracker() {
std::shared_ptr<Alertracker> mon(new Alertracker());
static std::shared_ptr<alert_tracker> create_alertracker() {
std::shared_ptr<alert_tracker> mon(new alert_tracker());
Globalreg::globalreg->alertracker = mon.get();
Globalreg::globalreg->RegisterLifetimeGlobal(mon);
Globalreg::globalreg->InsertGlobal(global_name(), mon);
Globalreg::globalreg->register_lifetime_global(mon);
Globalreg::globalreg->insert_global(global_name(), mon);
return mon;
}

private:
Alertracker();
alert_tracker();

// Raise an Prelude alert (requires prelude support compiled in)
int RaisePreludeAlert(int in_ref, kis_packet *in_pack, mac_addr bssid, mac_addr source,
int raise_prelude_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);
int RaisePreludeOneShot(std::string in_header, std::string in_text);
int raise_prelude_one_shot(std::string in_header, std::string in_text);

// Initialize Prelude Client (requires prelude support compiled in)
void PreludeInitClient(const char *analyzer_name);
void prelude_init_client(const char *analyzer_name);

public:
virtual ~Alertracker();
virtual ~alert_tracker();

// Register an alert and get an alert reference number back.
int RegisterAlert(std::string in_header, std::string in_desc,
int register_alert(std::string in_header, std::string in_desc,
alert_time_unit in_unit, int in_rate, alert_time_unit in_burstunit,
int in_burst, int in_phy);

// Find a reference from a name
int FetchAlertRef(std::string in_header);
int fetch_alert_ref(std::string in_header);

// Will an alert succeed?
int PotentialAlert(int in_ref);
int potential_alert(int in_ref);

// Raise an alert ...
int RaiseAlert(int in_ref, kis_packet *in_pack,
int 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);

// Raise a one-shot communications alert
int RaiseOneShot(std::string in_header, std::string in_text, int in_phy);
int raise_one_shot(std::string in_header, std::string in_text, int in_phy);

// parse an alert config string
int ParseAlertStr(std::string alert_str, std::string *ret_name,
int parse_alert_str(std::string alert_str, std::string *ret_name,
alert_time_unit *ret_limit_unit, int *ret_limit_rate,
alert_time_unit *ret_limit_burst, int *ret_burst_rate);

// Load alert rates from a config file
int ParseAlertConfig(ConfigFile *in_conf);
int parse_alert_config(config_file *in_conf);

// Define an alert and limits
int DefineAlert(std::string name, alert_time_unit limit_unit, int limit_rate,
int define_alert(std::string name, alert_time_unit limit_unit, int limit_rate,
alert_time_unit limit_burst, int burst_rate);

// Activate a preconfigured alert from a file
int ActivateConfiguredAlert(std::string in_header, std::string in_desc);
int ActivateConfiguredAlert(std::string in_header, std::string in_desc, int in_phy);
int activate_configured_alert(std::string in_header, std::string in_desc);
int activate_configured_alert(std::string in_header, std::string in_desc, int in_phy);

// Find an activated alert
int FindActivatedAlert(std::string in_header);
int find_activated_alert(std::string in_header);

virtual bool Httpd_VerifyPath(const char *path, const char *method);
virtual bool httpd_verify_path(const char *path, const char *method);

virtual void Httpd_CreateStreamResponse(Kis_Net_Httpd *httpd,
Kis_Net_Httpd_Connection *connection,
virtual void httpd_create_stream_response(kis_net_httpd *httpd,
kis_net_httpd_connection *connection,
const char *url, const char *method, const char *upload_data,
size_t *upload_data_size, std::stringstream &stream);

virtual int Httpd_PostComplete(Kis_Net_Httpd_Connection *concls);
virtual int httpd_post_complete(kis_net_httpd_connection *concls);

protected:
kis_recursive_timed_mutex alert_mutex;

std::shared_ptr<Packetchain> packetchain;
std::shared_ptr<EntryTracker> entrytracker;
std::shared_ptr<packet_chain> packetchain;
std::shared_ptr<entry_tracker> entrytracker;

int alert_vec_id, alert_entry_id, alert_timestamp_id, alert_def_id;

// Check and age times
int CheckTimes(shared_alert_def arec);
int check_times(shared_alert_def arec);

// Parse a foo/bar rate/unit option
int ParseRateUnit(std::string in_ru, alert_time_unit *ret_unit, int *ret_rate);
int parse_rate_unit(std::string in_ru, alert_time_unit *ret_unit, int *ret_rate);

int pack_comp_alert;
int alert_ref_kismet;
Expand All @@ -414,7 +414,7 @@ class Alertracker : public Kis_Net_Httpd_CPPStream_Handler, public LifetimeGloba
std::map<int, shared_alert_def> alert_ref_map;

// Tracked mapping for export
std::shared_ptr<TrackerElementVector> alert_defs_vec;
std::shared_ptr<tracker_element_vector> alert_defs_vec;

int num_backlog;

Expand Down
6 changes: 3 additions & 3 deletions antennatracker.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -21,9 +21,9 @@

Antennatracker::Antennatracker() {
antenna_id_map =
std::make_shared<TrackerElementIntMap>();
std::make_shared<tracker_element_int_map>();
antenna_endp =
std::make_shared<Kis_Net_Httpd_Simple_Tracked_Endpoint>("/antennas/antennas",
std::make_shared<kis_net_httpd_simple_tracked_endpoint>("/antennas/antennas",
antenna_id_map, &mutex);
next_ant_id = 0;
}
Expand All @@ -46,7 +46,7 @@ int Antennatracker::add_antenna(uuid in_src, int in_srcnum, int in_adjustment) {
auto ant = std::make_shared<tracked_antenna>();

uuid u;
u.GenerateRandomTimeUUID();
u.generate_random_time_uuid();

ant->set_id(next_ant_id++);
ant->set_source_uuid(in_src);
Expand Down
Loading

0 comments on commit 591d9cb

Please sign in to comment.