vrr/ntopng
2
0
Fork 0
mirror of https://github.com/ntop/ntopng.git synced 2026-04-30 16:09:32 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3
ntopng/include/NetworkInterface.h
emanuele-f d85fc2b06b Migrate interface alerts to in-memory alerts
2017-11-16 16:05:49 +01:00

642 lines
29 KiB
C++
Raw Blame History

/*
*
* (C) 2013-17 - ntop.org
*
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* 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.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
*/
#ifndef _NETWORK_INTERFACE_H_
#define _NETWORK_INTERFACE_H_
#include "ntop_includes.h"
/** @defgroup NetworkInterface Network Interface
* ............
*/
class Flow;
class FlowHash;
class Host;
class HostHash;
class Mac;
class MacHash;
class Vlan;
class VlanHash;
class AutonomousSystem;
class AutonomousSystemHash;
class DB;
class Paginator;
#ifdef NTOPNG_PRO
class AggregatedFlow;
class AggregatedFlowHash;
class L7Policer;
class FlowInterfacesStats;
class TrafficShaper;
#endif
typedef struct {
u_int32_t criteria; /* IP address, interface... */
NetworkInterface *iface;
UT_hash_handle hh; /* makes this structure hashable */
} FlowHashing;
/** @class NetworkInterface
* @brief Main class of network interface of ntopng.
* @details .......
*
* @ingroup NetworkInterface
*
*/
class NetworkInterface : public Checkpointable {
protected:
char *ifname, *ifDescription;
const char *customIftype;
u_int8_t alertLevel, purgeRuns;
u_int32_t bridge_lan_interface_id, bridge_wan_interface_id;
/* Disaggregations */
u_int16_t numVirtualInterfaces;
FlowHashingEnum flowHashingMode;
FlowHashing *flowHashing;
/* Network Discovery */
NetworkDiscovery *discovery;
MDNS *mdns;
SNMP *snmp;
string ip_addresses;
int id;
bool bridge_interface, is_dynamic_interface;
#ifdef NTOPNG_PRO
L7Policer *policer;
#ifndef HAVE_NEDGE
FlowProfiles *flow_profiles, *shadow_flow_profiles;
#endif
FlowInterfacesStats *flow_interfaces_stats;
AggregatedFlowHash *aggregated_flows_hash; /**< Hash used to store aggregated flows information. */
#endif
EthStats ethStats;
u_int32_t arp_requests, arp_replies;
ICMPstats icmp_v4, icmp_v6;
LocalTrafficStats localStats;
int pcap_datalink_type; /**< Datalink type of pcap. */
pthread_t pollLoop;
bool pollLoopCreated, has_too_many_hosts, has_too_many_flows, mtuWarningShown;
u_int32_t ifSpeed, numL2Devices, numHosts, numLocalHosts, scalingFactor;
u_int64_t checkpointPktCount, checkpointBytesCount, checkpointPktDropCount; /* Those will hold counters at checkpoints */
u_int16_t ifMTU;
int cpu_affinity; /**< Index of physical core where the network interface works. */
nDPIStats ndpiStats;
PacketStats pktStats;
FlowHash *flows_hash; /**< Hash used to store flows information. */
u_int32_t last_remote_pps, last_remote_bps;
/* Sub-interface views */
u_int8_t numSubInterfaces;
NetworkInterface *subInterfaces[MAX_NUM_VIEW_INTERFACES];
/* Lua */
bool user_scripts_reload_inline, user_scripts_reload_periodic;
lua_State *L_user_scripts_inline, *L_user_scripts_periodic;
u_int nextFlowAggregation;
TcpFlowStats tcpFlowStats;
TcpPacketStats tcpPacketStats;
/* Frequent Items */
FrequentTrafficItems *frequentProtocols;
FrequentTrafficItems *frequentMacs;
struct timeval last_frequent_reset;
/* Mac */
MacHash *macs_hash; /**< Hash used to store MAC information. */
/* Autonomous Systems */
AutonomousSystemHash *ases_hash; /**< Hash used to store Autonomous Systems information. */
/* Vlans */
VlanHash *vlans_hash; /**< Hash used to store Vlans information. */
/* Hosts */
HostHash *hosts_hash; /**< Hash used to store hosts information. */
bool purge_idle_flows_hosts, sprobe_interface, inline_interface,
dump_all_traffic, dump_to_tap, dump_to_disk, dump_unknown_traffic;
DB *db;
u_int dump_sampling_rate, dump_max_pkts_file, dump_max_duration, dump_max_files;
StatsManager *statsManager;
AlertsManager *alertsManager;
HostPools *host_pools;
bool has_vlan_packets, has_mac_addresses;
struct ndpi_detection_module_struct *ndpi_struct;
time_t last_pkt_rcvd, last_pkt_rcvd_remote, /* Meaningful only for ZMQ interfaces */
next_idle_flow_purge, next_idle_host_purge;
bool running, is_idle;
PacketDumper *pkt_dumper;
PacketDumperTuntap *pkt_dumper_tap;
NetworkStats *networkStats;
InterfaceStatsHash *interfaceStats;
lua_State* initUserScriptsInterpreter(const char *lua_file, const char *context);
void termLuaInterpreter();
void init();
void deleteDataStructures();
NetworkInterface* getSubInterface(u_int32_t criteria, bool parser_interface);
Flow* getFlow(Mac *srcMac, Mac *dstMac, u_int16_t vlan_id,
u_int32_t deviceIP, u_int16_t inIndex, u_int16_t outIndex,
IpAddress *src_ip, IpAddress *dst_ip,
u_int16_t src_port, u_int16_t dst_port,
u_int8_t l4_proto,
bool *src2dst_direction,
time_t first_seen, time_t last_seen,
u_int32_t rawsize,
bool *new_flow);
int sortHosts(struct flowHostRetriever *retriever,
u_int8_t bridge_iface_idx,
AddressTree *allowed_hosts,
bool host_details,
LocationPolicy location,
char *countryFilter, char *mac_filter,
u_int16_t vlan_id, char *osFilter,
u_int32_t asnFilter, int16_t networkFilter,
u_int16_t pool_filter, bool filtered_hosts, u_int8_t ipver_filter, int proto_filter,
bool hostMacsOnly, char *sortColumn);
int sortASes(struct flowHostRetriever *retriever,
char *sortColumn);
int sortVLANs(struct flowHostRetriever *retriever,
char *sortColumn);
int sortMacs(struct flowHostRetriever *retriever,
u_int8_t bridge_iface_idx,
u_int16_t vlan_id, bool sourceMacsOnly,
bool hostMacsOnly, bool dhcpMacsOnly,
const char *manufacturer,
char *sortColumn, u_int16_t pool_filter, u_int8_t devtype_filter,
u_int8_t location_filter);
int sortFlows(struct flowHostRetriever *retriever,
AddressTree *allowed_hosts,
Host *host,
Paginator *p,
const char *sortColumn);
bool isNumber(const char *str);
bool validInterface(char *name);
bool isInterfaceUp(char *name);
bool checkIdle();
void dumpPacketDisk(const struct pcap_pkthdr *h, const u_char *packet, dump_reason reason);
void dumpPacketTap(const struct pcap_pkthdr *h, const u_char *packet, dump_reason reason);
void disablePurge(bool on_flows);
void enablePurge(bool on_flows);
void sumStats(TcpFlowStats *_tcpFlowStats, EthStats *_ethStats,
LocalTrafficStats *_localStats, nDPIStats *_ndpiStats,
PacketStats *_pktStats, TcpPacketStats *_tcpPacketStats);
Host* findHostsByIP(AddressTree *allowed_hosts,
char *host_ip, u_int16_t vlan_id);
void topItemsCommit(const struct timeval *when);
public:
/**
* @brief A Constructor
* @details Creating a new NetworkInterface with all instance variables set to NULL.
*
* @return A new instance of NetworkInterface.
*/
NetworkInterface();
NetworkInterface(const char *name, const char *custom_interface_type = NULL);
virtual ~NetworkInterface();
virtual u_int32_t getASesHashSize();
virtual u_int32_t getVLANsHashSize();
virtual u_int32_t getMacsHashSize();
virtual u_int32_t getHostsHashSize();
virtual u_int32_t getFlowsHashSize();
virtual bool walker(WalkerType wtype, bool (*walker)(GenericHashEntry *h, void *user_data), void *user_data);
void checkAggregationMode();
inline void setCPUAffinity(int core_id) { cpu_affinity = core_id; };
virtual void startPacketPolling();
virtual void shutdown();
virtual void cleanup();
virtual char *getScriptName() { return NULL; }
virtual char *getEndpoint(u_int8_t id) { return NULL; };
virtual bool set_packet_filter(char *filter) { return(false); };
virtual void incrDrops(u_int32_t num) { ; }
/* calling virtual in constructors/destructors should be avoided
See C++ FAQ Lite covers this in section 23.7
*/
inline virtual bool isPacketInterface() { return(getIfType() != interface_type_FLOW); }
inline virtual bool isDiscoverableInterface(){ return(false); }
inline virtual char* altDiscoverableName() { return(NULL); }
inline virtual const char* get_type() { return(customIftype ? customIftype : CONST_INTERFACE_TYPE_UNKNOWN); }
inline virtual InterfaceType getIfType() { return(interface_type_UNKNOWN); }
inline FlowHash *get_flows_hash() { return flows_hash; }
inline TcpFlowStats* getTcpFlowStats() { return(&tcpFlowStats); }
inline virtual bool is_ndpi_enabled() { return(true); }
inline u_int getNumnDPIProtocols() { return(ndpi_get_num_supported_protocols(ndpi_struct)); };
inline time_t getTimeLastPktRcvd() { return(last_pkt_rcvd ? last_pkt_rcvd : last_pkt_rcvd_remote); };
inline void setTimeLastPktRcvd(time_t t) { last_pkt_rcvd = t; };
inline ndpi_protocol_category_t get_ndpi_proto_category(ndpi_protocol proto) { return(ndpi_get_proto_category(ndpi_struct, proto)); };
inline const char* get_ndpi_category_name(ndpi_protocol_category_t category) { return(ndpi_category_get_name(ndpi_struct, category)); };
ndpi_protocol_category_t get_ndpi_proto_category(u_int protoid);
inline char* get_ndpi_proto_name(u_int id) { return(ndpi_get_proto_name(ndpi_struct, id)); };
inline int get_ndpi_proto_id(char *proto) { return(ndpi_get_protocol_id(ndpi_struct, proto)); };
inline char* get_ndpi_proto_breed_name(u_int id) {
return(ndpi_get_proto_breed_name(ndpi_struct, ndpi_get_proto_breed(ndpi_struct, id))); };
inline u_int get_flow_size() { return(ndpi_detection_get_sizeof_ndpi_flow_struct()); };
inline u_int get_size_id() { return(ndpi_detection_get_sizeof_ndpi_id_struct()); };
inline char* get_name() { return(ifname); };
inline char* get_description() { return(ifDescription); };
inline int get_id() { return(id); };
inline bool get_sprobe_interface() { return sprobe_interface; }
inline bool get_inline_interface() { return inline_interface; }
inline bool hasSeenVlanTaggedPackets() { return(has_vlan_packets); }
inline void setSeenVlanTaggedPackets() { has_vlan_packets = true; }
inline bool hasSeenMacAddresses() { return(has_mac_addresses); }
inline void setSeenMacAddresses() { has_mac_addresses = true; }
inline struct ndpi_detection_module_struct* get_ndpi_struct() { return(ndpi_struct); };
inline bool is_sprobe_interface() { return(sprobe_interface); };
inline bool is_purge_idle_interface() { return(purge_idle_flows_hosts); };
inline void enable_sprobe() { sprobe_interface = true; };
int dumpFlow(time_t when, Flow *f);
#ifdef NTOPNG_PRO
int dumpAggregatedFlow(AggregatedFlow *f);
void flushFlowDump();
#endif
int dumpDBFlow(time_t when, Flow *f);
int dumpEsFlow(time_t when, Flow *f);
int dumpLsFlow(time_t when, Flow *f);
int dumpLocalHosts2redis(bool disable_purge);
inline void incRetransmittedPkts(u_int32_t num) { tcpPacketStats.incRetr(num); };
inline void incOOOPkts(u_int32_t num) { tcpPacketStats.incOOO(num); };
inline void incLostPkts(u_int32_t num) { tcpPacketStats.incLost(num); };
bool checkPointHostCounters(lua_State* vm, u_int8_t checkpoint_id, char *host_ip, u_int16_t vlan_id);
bool checkPointNetworkCounters(lua_State* vm, u_int8_t checkpoint_id, u_int8_t network_id);
inline bool checkPointInterfaceCounters(lua_State* vm, u_int8_t checkpoint_id) { checkpoint(vm, checkpoint_id); return true; }
void checkPointCounters(bool drops_only);
virtual char* serializeCheckpoint();
virtual u_int64_t getCheckPointNumPackets();
virtual u_int64_t getCheckPointNumBytes();
virtual u_int32_t getCheckPointNumPacketDrops();
inline void incFlagsStats(u_int8_t flags) { pktStats.incFlagStats(flags); };
inline void incStats(bool ingressPacket, time_t when, u_int16_t eth_proto, u_int16_t ndpi_proto,
u_int pkt_len, u_int num_pkts, u_int pkt_overhead, bool conntrack_update=false) {
#ifdef HAVE_NEDGE
if(! conntrack_update)
return;
#endif
ethStats.incStats(ingressPacket, eth_proto, num_pkts, pkt_len, pkt_overhead);
ndpiStats.incStats(when, ndpi_proto, 0, 0, 1, pkt_len);
// Note: here we are not currently interested in packet direction, so we tell it is receive
ndpiStats.incCategoryStats(when, get_ndpi_proto_category(ndpi_proto), 0 /* see above comment */, pkt_len);
pktStats.incStats(pkt_len);
};
inline void incLocalStats(u_int num_pkts, u_int pkt_len, bool localsender, bool localreceiver) {
localStats.incStats(num_pkts, pkt_len, localsender, localreceiver);
};
inline EthStats* getStats() { return(&ethStats); };
inline int get_datalink() { return(pcap_datalink_type); };
inline void set_datalink(int l) { pcap_datalink_type = l; };
inline int isRunning() { return running; };
bool restoreHost(char *host_ip, u_int16_t vlan_id);
u_int printAvailableInterfaces(bool printHelp, int idx, char *ifname, u_int ifname_len);
void findFlowHosts(u_int16_t vlan_id,
Mac *src_mac, IpAddress *_src_ip, Host **src,
Mac *dst_mac, IpAddress *_dst_ip, Host **dst);
virtual Flow* findFlowByKey(u_int32_t key, AddressTree *allowed_hosts);
bool findHostsByName(lua_State* vm, AddressTree *allowed_hosts, char *key);
bool findHostsByMac(lua_State* vm, u_int8_t *mac);
bool dissectPacket(u_int32_t bridge_iface_idx,
bool ingressPacket,
u_int8_t *sender_mac, /* Non NULL only for NFQUEUE interfaces */
const struct pcap_pkthdr *h, const u_char *packet,
u_int16_t *ndpiProtocol,
Host **srcHost, Host **dstHost, Flow **flow);
bool processPacket(u_int32_t bridge_iface_idx,
bool ingressPacket,
const struct bpf_timeval *when,
const u_int64_t time,
struct ndpi_ethhdr *eth,
u_int16_t vlan_id,
struct ndpi_iphdr *iph,
struct ndpi_ipv6hdr *ip6,
u_int16_t ipsize, u_int32_t rawsize,
const struct pcap_pkthdr *h,
const u_char *packet,
u_int16_t *ndpiProtocol,
Host **srcHost, Host **dstHost, Flow **flow);
void processFlow(ZMQ_Flow *zflow);
void processInterfaceStats(sFlowInterfaceStats *stats);
void dumpFlows();
void getnDPIStats(nDPIStats *stats, AddressTree *allowed_hosts, const char *host_ip, u_int16_t vlan_id);
void periodicStatsUpdate();
virtual void lua(lua_State* vm);
void getnDPIProtocols(lua_State *vm);
void getnDPIProtocols(lua_State *vm, ndpi_protocol_category_t filter);
void setnDPIProtocolCategory(u_int16_t protoId, ndpi_protocol_category_t protoCategory);
/**
* @brief Returns host statistics during latest activity
* @details Local hosts statistics may be flushed to redis when they become inactive.
* When they become active again, redis-stored statistics are restored.
* There is a limited number of cases that only need host statistics during
* the latest activity. This is for example true when computing
* minute-by-minute top statistics.
*
* The function is handy to retrieve compact, unsorted host statistics
* without including deserialized values for total local host bytes (sent and received).
*
* @param vm The lua state.
* @param allowed_hosts A patricia tree containing allowed hosts.
*/
int getLatestActivityHostsList(lua_State* vm,
AddressTree *allowed_hosts);
int getActiveHostsList(lua_State* vm,
u_int8_t bridge_iface_idx,
AddressTree *allowed_hosts,
bool host_details, LocationPolicy location,
char *countryFilter, char *mac_filter,
u_int16_t vlan_id, char *osFilter,
u_int32_t asnFilter, int16_t networkFilter,
u_int16_t pool_filter, bool filtered_hosts, u_int8_t ipver_filter, int proto_filter,
char *sortColumn, u_int32_t maxHits,
u_int32_t toSkip, bool a2zSortOrder);
int getActiveHostsGroup(lua_State* vm,
AddressTree *allowed_hosts,
bool host_details, LocationPolicy location,
char *countryFilter,
u_int16_t vlan_id, char *osFilter,
u_int32_t asnFilter, int16_t networkFilter,
u_int16_t pool_filter, bool filtered_hosts, u_int8_t ipver_filter,
bool hostsOnly, char *groupColumn);
int getActiveASList(lua_State* vm, const Paginator *p);
int getActiveVLANList(lua_State* vm,
char *sortColumn, u_int32_t maxHits,
u_int32_t toSkip, bool a2zSortOrder,
DetailsLevel details_level);
int getActiveMacList(lua_State* vm,
u_int8_t bridge_iface_idx,
u_int16_t vlan_id,
bool sourceMacsOnly,
bool hostMacsOnly, bool dhcpMacsOnly,
const char *manufacturer,
char *sortColumn, u_int32_t maxHits,
u_int32_t toSkip, bool a2zSortOrder,
u_int16_t pool_filter, u_int8_t devtype_filter,
u_int8_t location_filter);
int getActiveMacManufacturers(lua_State* vm,
u_int8_t bridge_iface_idx,
u_int16_t vlan_id,
bool sourceMacsOnly,
bool hostMacsOnly, bool dhcpMacsOnly,
u_int32_t maxHits, u_int8_t devtype_filter,
u_int8_t location_filter);
int getActiveDeviceTypes(lua_State* vm,
u_int8_t bridge_iface_idx,
u_int16_t vlan_id,
bool sourceMacsOnly,
bool hostMacsOnly, bool dhcpMacsOnly,
u_int32_t maxHits, const char *manufacturer,
u_int8_t location_filter);
int getMacsIpAddresses(lua_State *vm, int idx);
void getFlowsStats(lua_State* vm);
void getNetworksStats(lua_State* vm);
#ifdef NOTUSED
int getFlows(lua_State* vm, AddressTree *allowed_hosts,
Host *host, int ndpi_proto, LocationPolicy location,
char *sortColumn, u_int32_t maxHits,
u_int32_t toSkip, bool a2zSortOrder);
#endif
int getFlows(lua_State* vm, AddressTree *allowed_hosts,
Host *host,
Paginator *p);
int getFlowsGroup(lua_State* vm,
AddressTree *allowed_hosts,
Paginator *p,
const char *groupColumn);
int dropFlowsTraffic(AddressTree *allowed_hosts, Paginator *p);
virtual void purgeIdle(time_t when);
u_int purgeIdleFlows();
u_int purgeIdleHostsMacsASesVlans();
virtual u_int64_t getNumPackets();
virtual u_int64_t getNumBytes();
virtual u_int32_t getNumDroppedPackets() { return 0; };
virtual u_int getNumPacketDrops();
virtual u_int getNumFlows();
virtual u_int getNumL2Devices();
virtual u_int getNumHosts();
virtual u_int getNumLocalHosts();
virtual u_int getNumMacs();
virtual u_int getNumHTTPHosts();
void runHousekeepingTasks();
Vlan* getVlan(u_int16_t vlanId, bool createIfNotPresent);
AutonomousSystem *getAS(IpAddress *ipa, bool createIfNotPresent);
virtual Mac* getMac(u_int8_t _mac[6], u_int16_t vlanId, bool createIfNotPresent);
virtual Host* getHost(char *host_ip, u_int16_t vlan_id);
bool getHostInfo(lua_State* vm, AddressTree *allowed_hosts, char *host_ip, u_int16_t vlan_id);
void findUserFlows(lua_State *vm, char *username);
void findPidFlows(lua_State *vm, u_int32_t pid);
void findFatherPidFlows(lua_State *vm, u_int32_t pid);
void findProcNameFlows(lua_State *vm, char *proc_name);
void addAllAvailableInterfaces();
inline bool idle() { return(is_idle); }
inline u_int16_t getMTU() { return(ifMTU); }
inline void setIdleState(bool new_state) { is_idle = new_state; }
inline StatsManager *getStatsManager() { return statsManager; }
inline AlertsManager *getAlertsManager() { return alertsManager; }
void listHTTPHosts(lua_State *vm, char *key);
#ifdef NTOPNG_PRO
void refreshL7Rules();
void refreshShapers();
inline L7Policer* getL7Policer() { return(policer); }
inline FlowInterfacesStats* getFlowInterfacesStats() { return(flow_interfaces_stats); }
#endif
inline HostPools* getHostPools() { return(host_pools); }
PacketDumper *getPacketDumper(void) { return pkt_dumper; }
PacketDumperTuntap *getPacketDumperTap(void) { return pkt_dumper_tap; }
#ifdef NTOPNG_PRO
void updateHostsL7Policy(u_int16_t host_pool_id);
void updateFlowsL7Policy();
void resetPoolsStats();
inline void luaHostPoolsStats(lua_State *vm) { if (host_pools) host_pools->luaStats(vm); };
inline void luaHostPoolsVolatileMembers(lua_State *vm) { if (host_pools) host_pools->luaVolatileMembers(vm); };
#endif
void refreshHostPools();
inline u_int16_t getHostPool(Host *h) { if(h && host_pools) return host_pools->getPool(h); return NO_HOST_POOL_ID; };
inline u_int16_t getHostPool(Mac *m) { if(m && host_pools) return host_pools->getPool(m); return NO_HOST_POOL_ID; };
bool updateDumpAllTrafficPolicy(void);
bool updateDumpTrafficDiskPolicy();
bool updateDumpTrafficTapPolicy();
int updateDumpTrafficSamplingRate();
int updateDumpTrafficMaxPktsPerFile();
int updateDumpTrafficMaxSecPerFile();
int updateDumpTrafficMaxFiles(void);
inline bool getDumpTrafficDiskPolicy() { return(dump_to_disk); }
inline bool getDumpTrafficTapPolicy() { return(dump_to_tap); }
inline u_int getDumpTrafficSamplingRate() { return(dump_sampling_rate); }
inline u_int getDumpTrafficMaxPktsPerFile() { return(dump_max_pkts_file); }
inline u_int getDumpTrafficMaxSecPerFile() { return(dump_max_duration); }
inline u_int getDumpTrafficMaxFiles() { return(dump_max_files); }
inline char* getDumpTrafficTapName() { return(pkt_dumper_tap ? pkt_dumper_tap->getName() : (char*)""); }
void loadDumpPrefs();
void loadScalingFactorPrefs();
void getnDPIFlowsCount(lua_State *vm);
inline void setBridgeLanInterfaceId(u_int32_t v) { bridge_lan_interface_id = v; };
inline u_int32_t getBridgeLanInterfaceId() { return(bridge_lan_interface_id); };
inline void setBridgeWanInterfaceId(u_int32_t v) { bridge_wan_interface_id = v; };
inline u_int32_t getBridgeWanInterfaceId() { return(bridge_wan_interface_id); };
inline HostHash* get_hosts_hash() { return(hosts_hash); }
inline MacHash* get_macs_hash() { return(macs_hash); }
inline VlanHash* get_vlans_hash() { return(vlans_hash); }
inline AutonomousSystemHash* get_ases_hash() { return(ases_hash); }
inline bool is_bridge_interface() { return(bridge_interface); }
inline const char* getLocalIPAddresses() { return(ip_addresses.c_str()); }
void addInterfaceAddress(char *addr);
inline int exec_sql_query(lua_State *vm, char *sql, bool limit_rows, bool wait_for_db_created = true) {
return(db ? db->exec_sql_query(vm, sql, limit_rows, wait_for_db_created) : -1);
};
NetworkStats* getNetworkStats(u_int8_t networkId);
void allocateNetworkStats();
void getsDPIStats(lua_State *vm);
#ifdef NTOPNG_PRO
void updateFlowProfiles();
#ifndef HAVE_NEDGE
inline FlowProfile* getFlowProfile(Flow *f) { return(flow_profiles ? flow_profiles->getFlowProfile(f) : NULL); }
inline bool checkProfileSyntax(char *filter) { return(flow_profiles ? flow_profiles->checkProfileSyntax(filter) : false); }
#endif
bool passShaperPacket(TrafficShaper *a_shaper, TrafficShaper *b_shaper, struct pcap_pkthdr *h);
void initL7Policer();
#endif
void getFlowsStatus(lua_State *vm);
void startDBLoop() { if(db) db->startDBLoop(); };
inline bool createDBSchema() { if(db) { return db->createDBSchema(); } return false; };
inline bool createNprobeDBView() { if(db) { return db->createNprobeDBView(); } return false; };
#ifdef NTOPNG_PRO
inline void getFlowDevices(lua_State *vm) {
if(flow_interfaces_stats) flow_interfaces_stats->luaDeviceList(vm); else lua_newtable(vm);
};
inline void getFlowDeviceInfo(lua_State *vm, u_int32_t deviceIP) {
if(flow_interfaces_stats) flow_interfaces_stats->luaDeviceInfo(vm, deviceIP); else lua_newtable(vm);
};
#endif
inline void getSFlowDevices(lua_State *vm) {
if(interfaceStats) interfaceStats->luaDeviceList(vm); else lua_newtable(vm);
};
inline void getSFlowDeviceInfo(lua_State *vm, u_int32_t deviceIP) {
if(interfaceStats) interfaceStats->luaDeviceInfo(vm, deviceIP); else lua_newtable(vm);
};
void refreshHostsAlertPrefs(bool full_refresh);
int updateHostTrafficPolicy(AddressTree* allowed_networks, char *host_ip, u_int16_t host_vlan);
int setHostDumpTrafficPolicy(AddressTree* allowed_networks, char *host_ip, u_int16_t host_vlan, bool dump_traffic_to_disk);
int engageReleaseHostAlert(AddressTree* allowed_networks, char *host_ip, u_int16_t host_vlan, bool engage,
AlertEngine alert_engine,
char *engaged_alert_id, AlertType alert_type, AlertLevel alert_severity, const char *alert_json);
int luaEvalFlow(Flow *f, const LuaCallback cb);
inline void forceLuaInterpreterReload() { user_scripts_reload_inline = user_scripts_reload_periodic = true; };
inline virtual bool areTrafficDirectionsSupported() { return(false); };
inline virtual bool isView() { return(false); };
bool getMacInfo(lua_State* vm, char *mac, u_int16_t vlan_id);
bool setMacDeviceType(char *strmac, u_int16_t vlanId, DeviceType dtype, bool alwaysOverwrite);
bool setMacOperatingSystem(lua_State* vm, char *mac, OperatingSystem os);
bool getASInfo(lua_State* vm, u_int32_t asn);
bool getVLANInfo(lua_State* vm, u_int16_t vlan_id);
inline void incNumHosts(bool local) { if(local) numLocalHosts++; numHosts++; };
inline void decNumHosts(bool local) { if(local) numLocalHosts--; numHosts--; };
inline void incNumL2Devices() { numL2Devices++; }
inline void decNumL2Devices() { numL2Devices--; }
inline u_int32_t getScalingFactor() { return(scalingFactor); }
inline void setScalingFactor(u_int32_t f) { scalingFactor = f; }
inline bool isSampledTraffic() { return((scalingFactor == 1) ? false : true); }
inline void incAlertLevel() { alertLevel++; }
inline void decAlertLevel() { if(--alertLevel < 0) alertLevel = 0; }
inline int8_t getAlertLevel() { return(alertLevel); }
#ifdef NTOPNG_PRO
virtual void addIPToLRUMatches(u_int32_t client_ip, u_int16_t user_pool_id,
char *label, int32_t lifetime_sec) { ; };
void aggregatePartialFlow(Flow *flow);
#endif
inline char* mdnsResolveIPv4(u_int32_t ipv4addr /* network byte order */,
char *buf, u_int buf_len, u_int timeout_sec = 2) {
if(mdns)
return(mdns->resolveIPv4(ipv4addr, buf, buf_len, timeout_sec));
else {
buf[0] = '\0';
return(buf);
}
}
inline void mdnsSendAnyQuery(char *targetIPv4, char *query) {
if(mdns) mdns->sendAnyQuery(targetIPv4, query);
}
inline bool mdnsQueueResolveIPv4(u_int32_t ipv4addr, bool alsoUseGatewayDNS) {
return(mdns ? mdns->queueResolveIPv4(ipv4addr, alsoUseGatewayDNS) : false);
}
inline void mdnsFetchResolveResponses(lua_State* vm, int32_t timeout_sec = 2) {
if(mdns) mdns->fetchResolveResponses(vm, timeout_sec);
}
void topProtocolsAdd(u_int16_t pool_id, u_int16_t protocol, u_int32_t bytes);
inline void luaTopPoolsProtos(lua_State *vm) { frequentProtocols->luaTopPoolsProtocols(vm); }
void topMacsAdd(Mac *mac, u_int16_t protocol, u_int32_t bytes);
inline bool isDynamicInterface() { return(is_dynamic_interface); };
inline void setDynamicInterface() { is_dynamic_interface = true; };
inline void luaTopMacsProtos(lua_State *vm) { frequentMacs->luaTopMacsProtocols(vm); }
inline SNMP* getSNMP() { return(snmp); }
inline MDNS* getMDNS() { return(mdns); }
inline NetworkDiscovery* getNetworkDiscovery() { return(discovery); }
inline void incPoolNumHosts(u_int16_t id, bool isInlineCall) {
if (host_pools) host_pools->incNumHosts(id, isInlineCall);
};
inline void decPoolNumHosts(u_int16_t id, bool isInlineCall) {
if (host_pools) host_pools->decNumHosts(id, isInlineCall);
};
inline void incPoolNumL2Devices(u_int16_t id, bool isInlineCall) {
if (host_pools) host_pools->incNumL2Devices(id, isInlineCall);
};
inline void decPoolNumL2Devices(u_int16_t id, bool isInlineCall) {
if (host_pools) host_pools->decNumL2Devices(id, isInlineCall);
};
void updateFlowStats(u_int8_t protocol,
u_int32_t srcHost, u_int16_t sport,
u_int32_t dstHost, u_int16_t dport,
u_int32_t s2d_pkts, u_int32_t d2s_pkts,
u_int32_t s2d_bytes, u_int32_t d2s_bytes);
};
#endif /* _NETWORK_INTERFACE_H_ */
Reference in a new issue View git blame Copy permalink