NetworkInterface::Map NetworkInterface::get_interfaces_map() {
Map result{};
auto ifaces = get_ifaddrs();
for (auto* ifa = ifaces.get(); ifa; ifa = ifa->ifa_next) {
if (!ifa->ifa_addr) {
continue;
}
const auto family = ifa->ifa_addr->sa_family;
if (AF_PACKET == family || AF_INET == family
#ifdef NET_HAVE_IPv6
|| AF_INET6 == family
#endif
) {
const auto index = ::if_nametoindex(ifa->ifa_name);
auto it = result.find(index);
if (it == result.end()) {
it = result.emplace_hint(it, index,
NetworkInterface(iface_from_ifaddrs(index, ifa)));
}
if (AF_PACKET == family) {
continue;
}
if (it != result.end()) {
it->second.m_impl->add_address(address_from_ifaddrs(ifa));
}
}
}
return result;
}
PDU& PacketSenderGeneric::send_recv(PDU& spdu, SharedSender& shared_sender, const NetworkInterface& iface, bool promisc, double* rdelay, double* edelay)
{
//wait for previous packet to receive response (TODO: not ideal, plan future change)
while (sent_pdu) {
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
}
sent_pdu = spdu.clone();
//start sniff task
SnifferConfiguration config;
config.set_promisc_mode(promisc);
config.set_snap_len(65535);
config.set_timeout(10);
//Critical section
SHARED_SNIFFER_MUTEX.lock();
Sniffer sniffer{ iface.name(), config };
SHARED_SNIFFER_MUTEX.unlock();
bool compute_delay = true;
if (!rdelay)
compute_delay = false;
std::future<void> fresp(std::async(std::launch::async, &PacketSenderGeneric::sniff_task, this, &sniffer, compute_delay));
//send packet
std::clock_t effective_sent_time = std::clock();
std::cout << "Registering packet to send !" << std::endl;
shared_sender.register_packet(sent_pdu, NetworkInterface(iface));
//std::cout << "waiting for max " << timeout << "..." << std::endl;
std::future_status status = fresp.wait_for(std::chrono::seconds(timeout));
//raise exception in case of timeout
if (status == std::future_status::timeout)
{
sniffer.stop_sniff();
sent_pdu = NULL;
throw timeout_elapsed();
}
else if (status == std::future_status::deferred)
std::cout << "DEBUG: packet sniffing deffered... shouldn't happen";
//Treat response packet
if (edelay)
*edelay = ((std::clock() - effective_sent_time) / (double)CLOCKS_PER_SEC) * 1000;
if (rdelay) {
*rdelay = response_delay;
}
PDU& response(*this->response_pdu);
//Clean
sent_pdu = NULL;
response_delay = NULL;
//response_pdu = NULL;
return response;
}
void NetConfigureAll::execute()
{
bool needDefaultRoute = true;
for (const auto& interface : mNetwork.getInterfaces()) {
if (interface.getType() == InterfaceConfigType::LOOPBACK) {
NetworkInterface(interface.getHostIf(), 0).up();
} else if (interface.getType() == InterfaceConfigType::VETH_BRIDGED) {
NetworkInterface networkInterface(interface.getZoneIf(), 0);
Attrs attrs;
if (interface.getMTU() > 0) {
attrs.push_back(Attr{AttrName::MTU, std::to_string(interface.getMTU())});
}
if (!interface.getMACAddress().empty()) {
attrs.push_back(Attr{AttrName::MAC, interface.getMACAddress()});
}
if (interface.getTxLength() > 0) {
attrs.push_back(Attr{AttrName::TXQLEN, std::to_string(interface.getTxLength())});
}
networkInterface.setAttrs(attrs);
networkInterface.up();
// TODO: add container routing config to network configration
// NOTE: temporary - calc gw as a first IP in the network
InetAddr gw;
for (const auto& addr : interface.getAddrList()) {
networkInterface.addInetAddr(addr);
// NOTE: prefix 31 is used only for p2p (RFC3021)
if (gw.prefix == 0 && addr.type == InetAddrType::IPV4 && addr.prefix < 31) {
gw = addr;
unsigned mask = ((1 << addr.prefix) - 1) << (32 - addr.prefix);
unsigned net = ntohl(gw.getAddr<in_addr>().s_addr) & mask;
gw.getAddr<in_addr>().s_addr = htonl(net + 1);
}
}
if (needDefaultRoute && gw.prefix > 0) {
needDefaultRoute = false;
gw.prefix = 0;
networkInterface.addRoute(Route{
gw, //dst - gateway
InetAddr(), //src - not specified (prefix=0)
0,
"",
RoutingTable::UNSPEC
});
}
}
}
}
TrafficShapedSocket::TrafficShapedSocket(bool tcp, int ip_version) :
rdr(0),
up_gid(0),
down_gid(0),
mutex(QMutex::Recursive)
{
Socket* socket = new Socket(tcp, ip_version);
QString iface = NetworkInterface();
QStringList ips = NetworkInterfaceIPAddresses(iface);
if (ips.size() > 0)
socket->bind(ips.front(), 0, false);
sock = socket;
down_speed = new Speed();
up_speed = new Speed();
}
InterfaceData NetworkUpdater::getCurrentRawData()
{
auto data = InterfaceData();
auto interfaceNames = NetworkInterface::getAllInterfaceNames()->toVector();
for (auto name : interfaceNames)
{
auto interface = NetworkInterface(name);
auto transferData = TransferTypeData();
transferData.insert(NetworkTransferType::Download, interface.getCurrentAmount(NetworkTransferType::Download));
transferData.insert(NetworkTransferType::Upload, interface.getCurrentAmount(NetworkTransferType::Upload));
data.insert(name, transferData);
}
return data;
}
std::vector<NetworkInterface> WindowsNetworkEnvironment::getNetworkInterfaces() const {
std::vector<NetworkInterface> result;
ByteArray adapters;
ULONG bufferSize = 0;
ULONG ret;
ULONG flags = GAA_FLAG_INCLUDE_ALL_INTERFACES | GAA_FLAG_INCLUDE_PREFIX | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER;
while ((ret = GetAdaptersAddresses(AF_UNSPEC, flags, NULL, reinterpret_cast<IP_ADAPTER_ADDRESSES*>(vecptr(adapters)), &bufferSize)) == ERROR_BUFFER_OVERFLOW) {
adapters.resize(bufferSize);
};
if (ret != ERROR_SUCCESS) {
return result;
}
std::map<std::string,NetworkInterface> interfaces;
for (IP_ADAPTER_ADDRESSES* adapter = reinterpret_cast<IP_ADAPTER_ADDRESSES*>(vecptr(adapters)); adapter; adapter = adapter->Next) {
std::string name(adapter->AdapterName);
if (adapter->OperStatus != IfOperStatusUp) {
continue;
}
for (IP_ADAPTER_UNICAST_ADDRESS* address = adapter->FirstUnicastAddress; address; address = address->Next) {
boost::optional<HostAddress> hostAddress;
if (address->Address.lpSockaddr->sa_family == PF_INET) {
sockaddr_in* sa = reinterpret_cast<sockaddr_in*>(address->Address.lpSockaddr);
hostAddress = HostAddress(reinterpret_cast<const unsigned char*>(&(sa->sin_addr)), 4);
}
else if (address->Address.lpSockaddr->sa_family == PF_INET6) {
sockaddr_in6* sa = reinterpret_cast<sockaddr_in6*>(address->Address.lpSockaddr);
hostAddress = HostAddress(reinterpret_cast<const unsigned char*>(&(sa->sin6_addr)), 16);
}
if (hostAddress) {
std::map<std::string, NetworkInterface>::iterator i = interfaces.insert(std::make_pair(name, NetworkInterface(name, false))).first;
i->second.addAddress(*hostAddress);
}
}
}
for (std::map<std::string,NetworkInterface>::const_iterator i = interfaces.begin(); i != interfaces.end(); ++i) {
result.push_back(i->second);
}
return result;
}
void Device::addNetworkInterface(std::string name, Mac mac, Ip ip, bool isUp) {
networkInterfaces.push_back(NetworkInterface(name, mac, ip, isUp));
}
PDU *PacketSender::send_recv(PDU &pdu) {
return send_recv(pdu, NetworkInterface());
}
