CpiDeviceListUpnp::CpiDeviceListUpnp(FunctorCpiDevice aAdded, FunctorCpiDevice aRemoved) : CpiDeviceList(aAdded, aRemoved) , iStarted(false) , iXmlFetchSem("DRLS", 0) , iXmlFetchLock("DRLM") { NetworkInterfaceList& ifList = Stack::NetworkInterfaceList(); NetworkInterface* current = ifList.CurrentInterface(); iRefreshTimer = new Timer(MakeFunctor(*this, &CpiDeviceListUpnp::RefreshTimerComplete)); iInterfaceChangeListenerId = ifList.AddCurrentChangeListener(MakeFunctor(*this, &CpiDeviceListUpnp::CurrentNetworkInterfaceChanged)); iSubnetChangeListenerId = ifList.AddSubnetChangeListener(MakeFunctor(*this, &CpiDeviceListUpnp::SubnetChanged)); if (current == NULL) { iInterface = 0; iUnicastListener = NULL; iMulticastListener = NULL; iNotifyHandlerId = 0; } else { iInterface = current->Address(); iUnicastListener = new SsdpListenerUnicast(*this, iInterface); iMulticastListener = &Stack::MulticastListenerClaim(iInterface); iNotifyHandlerId = iMulticastListener->AddNotifyHandler(this); delete current; } }
/*! Scans an interface and enumerates all baos devices. It sends a search request as outlined in the BAOS 1.2 protocol documentation and waits for the responses. There are lots of magic numbers here and hard-coded offsets... See the spec for more information on what is happening here... We implement a receive timeout, and keep receiving until this timeout elapses. If this timeout is too fast, increase it to 500 or 1000 for example. */ void BaosIpEnumerator::scanInterface(const NetworkInterface& networkInterface) { poco_information(LOGGER(), format("Search devices on interface: %s (%s)", networkInterface.displayName(), networkInterface.address().toString())); try { // initialize socket MulticastSocket socket; socket.bind(SocketAddress(networkInterface.address(), 0)); socket.setTimeToLive(DefaultMulticastTTL); // builds and sends a SEARCH_REQUEST to the socket sendSearchRequestFrame(socket); // wait for SEARCH_RESPONSES and collect it waitForSearchResponseFrames(socket); } catch (Poco::Exception& e) { poco_warning(LOGGER(), format("... search failed with error: %s", e.displayText())); } }
void CpiDeviceListUpnp::HandleInterfaceChange(TBool aNewSubnet) { NetworkInterface* current = Stack::NetworkInterfaceList().CurrentInterface(); iLock.Wait(); delete iUnicastListener; iUnicastListener = NULL; if (iMulticastListener != NULL) { iMulticastListener->RemoveNotifyHandler(iNotifyHandlerId); iNotifyHandlerId = 0; Stack::MulticastListenerRelease(iInterface); iMulticastListener = NULL; } if (current == NULL) { iInterface = 0; RemoveAll(); iLock.Signal(); return; } iInterface = current->Address(); delete current; if (aNewSubnet) { RemoveAll(); } iUnicastListener = new SsdpListenerUnicast(*this, iInterface); iUnicastListener->Start(); iMulticastListener = &Stack::MulticastListenerClaim(iInterface); iNotifyHandlerId = iMulticastListener->AddNotifyHandler(this); iLock.Signal(); Refresh(); }
void test_bring_up_down() { NetworkInterface* net = MBED_CONF_APP_OBJECT_CONSTRUCTION; for (int i = 0; i < COUNT; i++) { int err = MBED_CONF_APP_CONNECT_STATEMENT; TEST_ASSERT_EQUAL(0, err); printf("MBED: IP Address %s\r\n", net->get_ip_address()); TEST_ASSERT(net->get_ip_address()); UDPSocket udp; err = udp.open(net); TEST_ASSERT_EQUAL(0, err); err = udp.close(); TEST_ASSERT_EQUAL(0, err); TCPSocket tcp; err = tcp.open(net); TEST_ASSERT_EQUAL(0, err); err = tcp.close(); TEST_ASSERT_EQUAL(0, err); err = net->disconnect(); TEST_ASSERT_EQUAL(0, err); } }
void PacketSender::open_l2_socket(const NetworkInterface& iface) { #if defined(BSD) || defined(__FreeBSD_kernel__) int sock = -1; // At some point, there should be an available device for (int i = 0; sock == -1;i++) { std::ostringstream oss; oss << "/dev/bpf" << i; sock = open(oss.str().c_str(), O_RDWR); } if(sock == -1) throw socket_open_error(make_error_string()); struct ifreq ifr; strncpy(ifr.ifr_name, iface.name().c_str(), sizeof(ifr.ifr_name) - 1); if(ioctl(sock, BIOCSETIF, (caddr_t)&ifr) < 0) { ::close(sock); throw socket_open_error(make_error_string()); } _ether_socket[iface.id()] = sock; #else if (_ether_socket == INVALID_RAW_SOCKET) { _ether_socket = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL)); if (_ether_socket == -1) throw socket_open_error(make_error_string()); } #endif }
static void _ifup() { NetworkInterface *net = NetworkInterface::get_default_instance(); nsapi_error_t err = net->connect(); TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, err); printf("MBED: TLSClient IP address is '%s'\n", net->get_ip_address()); }
void RedirectorSrv::server_sockevent( nlink_server *cptr, uint16 revents, void *myNet ) { NetworkInterface * client; struct nlink_client *ncptr; if(revents & PF_READ) { client = ( ( NetworkInterface * ) myNet )->getConnection( ); if (!client) return; uint32 nonblockingstate = true; IOCTL_SOCKET( client->getSocketID(), IOCTL_NOBLOCK, &nonblockingstate ); ncptr = new nlink_client; if(ncptr == NULL) return; memset(ncptr, 0, sizeof(*ncptr)); ncptr->hdr.type = RCLIENT; ncptr->hdr.fd = client->getSocketID(); nlink_insert((struct nlink *)ncptr); Client *pClient = new Client(); pClient->BindNI(client); ncptr->pClient = pClient; pClient->getNetwork()->sendData( mDestination.length( ), mDestination.c_str( ) ); Log::getSingleton( ).outString( "REDIRECTOR: Sent world server" ); disconnect_client( ncptr ); } }
int HistoricalInterface::loadData() { time_t actual_epoch, adjust_to_epoch; int ret_state = CONST_HISTORICAL_OK; NetworkInterface * iface = ntop->getInterfaceById(interface_id); if((iface != NULL) && (from_epoch != 0) && (to_epoch != 0)) { u_int8_t iface_dump_id; iface_dump_id = iface->get_id(); actual_epoch = from_epoch; adjust_to_epoch = to_epoch - 300; // Adjust to epoch each file contains 5 minute of data while (actual_epoch <= adjust_to_epoch && isRunning()) { char path[MAX_PATH]; char db_path[MAX_PATH]; memset(path, 0, sizeof(path)); memset(db_path, 0, sizeof(db_path)); strftime(path, sizeof(path), "%Y/%m/%d/%H/%M", localtime(&actual_epoch)); snprintf(db_path, sizeof(db_path), "%s/%u/flows/%s.sqlite", ntop->get_working_dir(), iface_dump_id , path); loadData(db_path); num_historicals++; actual_epoch += 300; // 5 minute steps } } on_load = false; return ret_state; }
void NetworkInterfaceTest::testForAddress() { NetworkInterface::Map map = NetworkInterface::map(); for (NetworkInterface::Map::const_iterator it = map.begin(); it != map.end(); ++it) { // not all interfaces have IP configured if (it->second.addressList().empty()) continue; if (it->second.supportsIPv4()) { NetworkInterface ifc = NetworkInterface::forAddress(it->second.firstAddress(IPAddress::IPv4)); assert (ifc.firstAddress(IPAddress::IPv4) == it->second.firstAddress(IPAddress::IPv4)); IPAddress addr(IPAddress::IPv4); assert (addr.isWildcard()); it->second.firstAddress(addr, IPAddress::IPv4); assert (!addr.isWildcard()); } else { try { it->second.firstAddress(IPAddress::IPv4); fail ("must throw"); } catch (NotFoundException&) { } IPAddress addr(IPAddress::IPv4); assert (addr.isWildcard()); it->second.firstAddress(addr, IPAddress::IPv4); assert (addr.isWildcard()); } } }
void NetworkInterface::onPacketReceivedCb(u_char *user, const struct pcap_pkthdr *h, const u_char *bytes) { NetworkInterface *host = reinterpret_cast<NetworkInterface*>(user); host->onPacketReceived(h, bytes); }
int main(int argc, const char *argv[]) { NetworkInterface ni; ni.hostGame(); ni.endGame(); return 0; }
void NetworkInterfaceTest::testForIndex() { NetworkInterface::Map map = NetworkInterface::map(); for (NetworkInterface::Map::const_iterator it = map.begin(); it != map.end(); ++it) { NetworkInterface ifc = NetworkInterface::forIndex(it->second.index()); assert (ifc.index() == it->second.index()); } }
static void RandomiseUdn(Bwh& aUdn) { aUdn.Grow(aUdn.Bytes() + 1 + Ascii::kMaxUintStringBytes + 1); aUdn.Append('-'); Bws<Ascii::kMaxUintStringBytes> buf; NetworkInterface* nif = Stack::NetworkInterfaceList().CurrentInterface(); TUint max = nif->Address(); delete nif; (void)Ascii::AppendDec(buf, Random(max)); aUdn.Append(buf); aUdn.PtrZ(); }
void MulticastSocket::setInterface(const NetworkInterface& interface) { if (!interface.supportsIPv6()) { impl()->setOption(IPPROTO_IP, IP_MULTICAST_IF, interface.address()); } else { #if defined(POCO_HAVE_IPv6) impl()->setOption(IPPROTO_IPV6, IPV6_MULTICAST_IF, interface.index()); #endif } }
void MULTIHOMING_ASYNCHRONOUS_DNS() { rtos::Semaphore semaphore; dns_application_data data; data.semaphore = &semaphore; for (unsigned int i = 0; i < MBED_CONF_APP_DNS_TEST_HOSTS_NUM; i++) { for (unsigned int interface_index = 0; interface_index < MBED_CONF_MULTIHOMING_MAX_INTERFACES_NUM; interface_index++) { NetworkInterface *interface = get_interface(interface_index); if (interface == NULL) { continue; } for (unsigned int j = 0; j < interface_num; j++) { nsapi_error_t err = interface->gethostbyname_async(dns_test_hosts[i], mbed::Callback<void(nsapi_error_t, SocketAddress *)>(hostbyname_cb, (void *) &data), NSAPI_UNSPEC, interface_name[j]); TEST_ASSERT(err >= 0); semaphore.wait(); TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, data.result); printf("DNS: query interface_name %s %d \n", interface_name[j], j); if (data.result == NSAPI_ERROR_OK) { result_ok++; printf("DNS: query OK \"%s\" => \"%s\"\n", dns_test_hosts[i], data.addr.get_ip_address()); } else if (data.result == NSAPI_ERROR_DNS_FAILURE) { result_dns_failure++; printf("DNS: query \"%s\" => DNS failure\n", dns_test_hosts[i]); } else if (data.result == NSAPI_ERROR_TIMEOUT) { result_exp_timeout++; printf("DNS: query \"%s\" => timeout\n", dns_test_hosts[i]); } else if (data.result == NSAPI_ERROR_NO_MEMORY) { result_no_mem++; printf("DNS: query \"%s\" => no memory\n", dns_test_hosts[i]); } else { printf("DNS: query \"%s\" => %d, unexpected answer\n", dns_test_hosts[i], data.result); TEST_ASSERT(data.result == NSAPI_ERROR_OK || data.result == NSAPI_ERROR_NO_MEMORY || data.result == NSAPI_ERROR_DNS_FAILURE || data.result == NSAPI_ERROR_TIMEOUT); } } } } }
void MulticastSocket::setInterface(const NetworkInterface& interfc) { if (address().family() == IPAddress::IPv4) { impl()->setOption(IPPROTO_IP, IP_MULTICAST_IF, interfc.firstAddress(IPAddress::IPv4)); } #if defined(POCO_HAVE_IPv6) else if (address().family() == IPAddress::IPv6) { impl()->setOption(IPPROTO_IPV6, IPV6_MULTICAST_IF, interfc.index()); } #endif else throw UnsupportedFamilyException("Unknown or unsupported socket family."); }
// Send syns to the given ip address, using the destination ports provided. void send_syns(const NetworkInterface &iface, IPv4Address dest_ip, const vector<string> &ips) { // Retrieve the addresses. NetworkInterface::Info info = iface.addresses(); PacketSender sender; // Allocate the IP PDU IP ip = IP(dest_ip, info.ip_addr) / TCP(); // Get the reference to the TCP PDU TCP &tcp = ip.rfind_pdu<TCP>(); // Set the SYN flag on. tcp.set_flag(TCP::SYN, 1); // Just some random port. tcp.sport(1337); cout << "Sending SYNs..." << endl; for(vector<string>::const_iterator it = ips.begin(); it != ips.end(); ++it) { // Set the new port and send the packet! tcp.dport(atoi(it->c_str())); sender.send(ip); } // Wait 1 second. sleep(1); /* Special packet to indicate that we're done. This will be sniffed * by our function, which will in turn return false. */ tcp.set_flag(TCP::RST, 1); // Pretend we're the scanned host... ip.src_addr(dest_ip); // We use an ethernet pdu, otherwise the kernel will drop it. EthernetII eth = EthernetII(info.hw_addr, info.hw_addr) / ip; sender.send(eth, iface); }
void receive_probe_requests(NetworkInterface iface) { SnifferConfiguration config; config.set_rfmon(true); config.set_filter("type mgt subtype probe-req || type data subtype null"); Sniffer sniffer(iface.name(), config); while(true) process(sniffer.next_packet()); }
NetworkInterfaceBytes EmittedReceivedBytes::getEmittedReceivedNumberOfBytesNow( pid_t pid, const NetworkInterface &networkInterface) { NetworkInterfaceBytes result(networkInterface.getName()); QFile statFile(statFileName.arg(pid)); if (!statFile.open(QIODevice::ReadOnly | QIODevice::Text)) { logger.log(Logger::LOG_ERROR, "unable to read stat file"); return result; } QTextStream statFileStream(&statFile); // Skip the first line statFileStream.readLine(); // TODO get the real received/transmit bytes according to the specified network interface // (cause now, we cannot know what interface is used) QStringList values( statFileStream.readLine().split(QRegExp("\\s+"), QString::SkipEmptyParts)); long emittedBytes = values[5].toLong() + values[9].toLong() + values[12].toLong(); result.setEmittedBytes(emittedBytes); long receivedBytes = values[7].toLong() + values[11].toLong() + values[13].toLong(); result.setReceivedBytes(receivedBytes); return result; }
bool PacketSender::ether_socket_initialized(const NetworkInterface& iface) const { #if defined(BSD) || defined(__FreeBSD_kernel__) return _ether_socket.count(iface.id()); #else return _ether_socket != INVALID_RAW_SOCKET; #endif }
void RadioTap::send(PacketSender &sender, const NetworkInterface &iface) { if(!iface) throw invalid_interface(); #if !defined(BSD) && !defined(__FreeBSD_kernel__) struct sockaddr_ll addr; memset(&addr, 0, sizeof(struct sockaddr_ll)); addr.sll_family = Endian::host_to_be<uint16_t>(PF_PACKET); addr.sll_protocol = Endian::host_to_be<uint16_t>(ETH_P_ALL); addr.sll_halen = 6; addr.sll_ifindex = iface.id(); const Tins::Dot11 *wlan = tins_cast<Tins::Dot11*>(inner_pdu()); if(wlan) { Tins::Dot11::address_type dot11_addr(wlan->addr1()); std::copy(dot11_addr.begin(), dot11_addr.end(), addr.sll_addr); } sender.send_l2(*this, (struct sockaddr*)&addr, (uint32_t)sizeof(addr)); #else sender.send_l2(*this, 0, 0, iface); #endif }
static int ntop_set_active_interface_id(lua_State* vm) { NetworkInterface *iface; u_int32_t id; if(ntop_lua_check(vm, __FUNCTION__, 1, LUA_TNUMBER)) return(CONST_LUA_ERROR); id = (u_int32_t)lua_tonumber(vm, 1); iface = ntop->getInterfaceId(id); if(iface != NULL) lua_pushstring(vm, iface->get_name()); else lua_pushnil(vm); return(CONST_LUA_OK); }
void PacketSender::close_socket(SocketType type, const NetworkInterface &iface) { if(type == ETHER_SOCKET) { #if defined(BSD) || defined(__FreeBSD_kernel__) BSDEtherSockets::iterator it = _ether_socket.find(iface.id()); if(it == _ether_socket.end()) throw invalid_socket_type(); if(::close(it->second) == -1) throw socket_close_error(make_error_string()); _ether_socket.erase(it); #elif !defined(WIN32) if(_ether_socket == INVALID_RAW_SOCKET) throw invalid_socket_type(); if(::close(_ether_socket) == -1) throw socket_close_error(make_error_string()); _ether_socket = INVALID_RAW_SOCKET; #endif } else { if(type >= SOCKETS_END || _sockets[type] == INVALID_RAW_SOCKET) throw invalid_socket_type(); #ifndef WIN32 if(close(_sockets[type]) == -1) throw socket_close_error(make_error_string()); #else closesocket(_sockets[type]); #endif _sockets[type] = INVALID_RAW_SOCKET; } }
const std::string RmmKeyGenerator::generate_key(const NetworkInterface& interface) { const auto mac_address = interface.get_mac_address(); if (!mac_address.has_value()) { throw KeyValueMissingError("MAC address is missing."); } return generate_key_base(interface) + mac_address.value(); }
int PacketSender::get_ether_socket(const NetworkInterface& iface) { if(!ether_socket_initialized(iface)) open_l2_socket(iface); #if defined(BSD) || defined(__FreeBSD_kernel__) return _ether_socket[iface.id()]; #else return _ether_socket; #endif }
NetworkState::NetworkState(String interfaceName): interfaceName_(interfaceName), networkMask_(0) { Ref<RouteInfoList> routingTable = RouteInfo::queryTable(); for (int i = 0; i < routingTable->count(); ++i) { RouteInfo *entry = routingTable->at(i); if (entry->source() || entry->destination()) continue; if (interfaceName_ != "" && entry->outputInterface() != interfaceName_) continue; interfaceName_ = entry->outputInterface(); gateway_ = entry->gateway(); break; } Ref<NetworkInterfaceList> interfaceList = NetworkInterface::queryAll(AF_UNSPEC); for (int i = 0; i < interfaceList->count(); ++i) { NetworkInterface *candidate = interfaceList->at(i); if (candidate->name() == interfaceName_) { interface_ = candidate; Ref<SocketAddressList> addressList = interface_->addressList(); if (!gateway_) { for (int j = 0; j < addressList->count(); ++j) { SocketAddress *address = addressList->at(j); if (address->family() != AF_INET) continue; address_ = address; break; } } if (!address_) { for (int j = 0; j < addressList->count(); ++j) { SocketAddress *address = addressList->at(j); if (gateway_ && address->family() != gateway_->family()) continue; address_ = address; break; } } } } Ref<SocketAddressEntry> entry = cast<SocketAddressEntry>(address_); if (entry) networkMask_ = entry->networkMask(); }
const std::string RmmKeyGenerator::generate_key(const Fan& fan, const NetworkInterface& zone_network_interface) { const auto zone_nic_mac = zone_network_interface.get_mac_address(); const auto slot_id = fan.get_slot_id(); if (!zone_nic_mac.has_value()) { throw KeyValueMissingError("Zone NIC MAC address is missing."); } return generate_key_base(fan) + zone_nic_mac.value() + std::to_string(static_cast<unsigned int>(slot_id)); }
void MulticastSocket::leaveGroup(const IPAddress& groupAddress, const NetworkInterface& interfc) { if (groupAddress.af() == AF_INET) { struct ip_mreq mr; std::memcpy(&mr.imr_multiaddr, groupAddress.addr(), groupAddress.length()); std::memcpy(&mr.imr_interface, interfc.firstAddress(IPAddress::IPv4).addr(), interfc.firstAddress(IPAddress::IPv4).length()); impl()->setRawOption(IPPROTO_IP, IP_DROP_MEMBERSHIP, &mr, sizeof(mr)); } else { #if defined(POCO_HAVE_IPv6) struct ipv6_mreq mr; std::memcpy(&mr.ipv6mr_multiaddr, groupAddress.addr(), groupAddress.length()); mr.ipv6mr_interface = interfc.index(); impl()->setRawOption(IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP, &mr, sizeof(mr)); #endif } }
const std::string RmmKeyGenerator::generate_key(const ThermalZone& thermal_zone, const NetworkInterface& zone_network_interface) { const auto zone_nic_mac = zone_network_interface.get_mac_address(); if (!zone_nic_mac.has_value()) { throw KeyValueMissingError("Zone NIC MAC address is missing."); } return generate_key_base(thermal_zone) + zone_nic_mac.value(); }
const std::string RmmKeyGenerator::generate_key(const EthernetSwitchPortVlan& vlan, const NetworkInterface& network_interface) { const auto vlan_id = vlan.get_vlan_id(); const auto nic_mac = network_interface.get_mac_address(); if ((!vlan_id.has_value()) || (!nic_mac.has_value())) { throw KeyValueMissingError("Unique propery not found."); } return generate_key_base(vlan) + std::to_string(vlan_id.value()) + nic_mac.value(); }