def main(iface): # Get IP and mask ipHost = netifaces.ifaddresses(iface)[netifaces.AF_INET][0]['addr'] mask = netifaces.ifaddresses(iface)[netifaces.AF_INET][0]['netmask'] # Calculate the CIDR value maskCIDR = maskToCIDR(mask) tlwpa4230pIPs = [] network = ipaddress.ip_network('{}/{}'.format(ipHost, maskCIDR), strict=False) print ('-- Scanning {} addresses...'.format(network.num_addresses - 2)) for addr in network.hosts(): # Check if the addr belongs to a TL-WPA4230P powerline adapter res = checkTLWPA4230P(str(addr)) if res: print('{} is a TL-WPA4230P powerline adapter!'.format(str(addr))) tlwpa4230pIPs.append(str(addr)) print('-- Scan completed.') # Open the web interface of the powerline adapters found for ip in tlwpa4230pIPs: print('Opening {} in web browser...'.format(ip)) xdgOpenProcess = subprocess.Popen(['xdg-open', 'http://{}'.format(ip)], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) xdgOpenProcess.wait()
def get_interfaces(self): ''' Retrieve the interfaces of the VM ''' interfaces = netifaces.interfaces() self.interfaces = [] for interface in interfaces: if interface == 'lo': continue default_gw = '' configuration_type = None gws = netifaces.gateways() if gws['default'] != {} and gws['default'][netifaces.AF_INET][1] == interface: default_gw = gws['default'][netifaces.AF_INET][0] interface_af_link_info = netifaces.ifaddresses(interface)[17] if 2 in netifaces.ifaddresses(interface): interface_af_inet_info = netifaces.ifaddresses(interface)[2] ipv4_address = interface_af_inet_info[0]['addr'] netmask = interface_af_inet_info[0]['netmask'] else: ipv4_address = "" netmask = "" if interface == constants.configuration_interface: _type = 'config' configuration_type = 'dhcp' else: _type = 'not_defined' self.interfaces.append(Interface(name = interface, status = None, mac_address = interface_af_link_info[0]['addr'], ipv4_address = ipv4_address, netmask = netmask, default_gw = default_gw, _type = _type, configuration_type = configuration_type))
def getLocalIP(): if _platform == "darwin": interfaceName = "en0" else: interfaceName = "eth0" netifaces.ifaddresses(interfaceName) return netifaces.ifaddresses(interfaceName)[2][0]['addr']
def update(self): """Update IP stats using the input method. Stats is dict """ # Init new stats stats = self.get_init_value() if self.input_method == 'local' and not import_error_tag: # Update stats using the netifaces lib try: default_gw = netifaces.gateways()['default'][netifaces.AF_INET] except (KeyError, AttributeError) as e: logger.debug("Cannot grab the default gateway ({})".format(e)) else: try: stats['address'] = netifaces.ifaddresses(default_gw[1])[netifaces.AF_INET][0]['addr'] stats['mask'] = netifaces.ifaddresses(default_gw[1])[netifaces.AF_INET][0]['netmask'] stats['mask_cidr'] = self.ip_to_cidr(stats['mask']) stats['gateway'] = netifaces.gateways()['default'][netifaces.AF_INET][0] stats['public_address'] = self.public_address except (KeyError, AttributeError) as e: logger.debug("Cannot grab IP information: {}".format(e)) elif self.input_method == 'snmp': # Not implemented yet pass # Update the stats self.stats = stats return self.stats
def _update_widgets(self, widgets): interfaces = [ i for i in netifaces.interfaces() if not i.startswith(self._exclude) ] for widget in widgets: widget.set("visited", False) for intf in interfaces: addr = [] state = "down" try: if netifaces.AF_INET in netifaces.ifaddresses(intf): for ip in netifaces.ifaddresses(intf)[netifaces.AF_INET]: if "addr" in ip and ip["addr"] != "": addr.append(ip["addr"]) state = "up" except Exception as e: addr = [] widget = self.widget(intf) if not widget: widget = bumblebee.output.Widget(name=intf) widgets.append(widget) widget.full_text("{}".format(",".join(addr))) #widget.full_text("{} {} {}".format(intf, state, ", ".join(addr))) widget.set("intf", intf) widget.set("state", state) widget.set("visited", True) for widget in widgets: if widget.get("visited") == False: widgets.remove(widget)
def main(): # bssid = get_bssid(iface) # needs try / catch iface = netifaces.gateways()['default'][netifaces.AF_INET][1] conf.iface = iface local_mac = netifaces.ifaddresses(iface)[netifaces.AF_LINK][0]['addr'] local_ip = netifaces.ifaddresses(iface)[netifaces.AF_INET][0]['addr'] print local_mac print local_ip bssid = get_bssid(iface) nm = nmap.PortScanner() nm_scan = nm.scan(hosts = '192.168.0.0/24', arguments='-sP') eligible_hosts = collect_eligible_hosts(nm_scan, local_ip, '192.168.0.1') display_eligible_hosts(eligible_hosts) user_choice = ask_user() enable_monitor_mode(iface) # client_to_deauth = eligible_hosts[2].mac_address while (True): for e in eligible_hosts: for n in range(20): sendp(RadioTap()/Dot11(type=0,subtype=12,addr1=test_client,addr2=bssid,addr3=bssid)/Dot11Deauth(reason=7))
def run(self): silent = positive(self.parameters['SILENT'].value) import netifaces as n ifs = n.interfaces() result = {} for iface in ifs: afs = {} for ad in n.ifaddresses(iface): afs[n.address_families[ad]] = n.ifaddresses(iface)[ad] result[iface] = afs #output if not silent: for interface in result: log.ok('%s:' % interface) for afamily in result[interface]: log.ok(' %s:' %afamily) for addressid in range(0, len(result[interface][afamily])): log.ok(' address %d:' % addressid) address = result[interface][afamily][addressid] for key in address: log.ok(' %s = %s' % (key, address[key])) #lib.kb.add('NETWORK INTERFACES', result) for x in result: lib.kb.add('NETWORK INTERFACES %s' % (x), result[x]) # # # # # # # # return None
def get_interfaces(self): ''' Retrieve the interfaces of the VM ''' interfaces = netifaces.interfaces() self.interfaces = [] for interface in interfaces: if interface == 'lo': continue default_gw = '' gws = netifaces.gateways() #logging.debug("GATEWAY: "+str(gws)) #logging.debug("GATEWAY: "+str(gws['default'])) #logging.debug("GATEWAY: "+str(gws['default'][netifaces.AF_INET])) if gws['default'] == {}: default_gw = '' else: for gw in gws[netifaces.AF_INET]: if gw[1] == interface: default_gw = gw[0] interface_af_link_info = netifaces.ifaddresses(interface)[17] if 2 in netifaces.ifaddresses(interface): interface_af_inet_info = netifaces.ifaddresses(interface)[2] ipv4_address = interface_af_inet_info[0]['addr'] netmask = interface_af_inet_info[0]['netmask'] else: ipv4_address = "" netmask = "" self.interfaces.append(Interface(name = interface, status = None, mac_address = interface_af_link_info[0]['addr'], ipv4_address = ipv4_address, netmask = netmask, default_gw = default_gw))
def get_info(self, interface): format_dict = dict(v4="", v4mask="", v4cidr="", v6="", v6mask="", v6cidr="") iface_up = sysfs_interface_up(interface, self.unknown_up) if not iface_up: return format_dict network_info = netifaces.ifaddresses(interface) slaves = get_bonded_slaves() try: master = slaves[interface] except KeyError: pass else: if sysfs_interface_up(interface, self.unknown_up): master_info = netifaces.ifaddresses(master) for af in (netifaces.AF_INET, netifaces.AF_INET6): try: network_info[af] = master_info[af] except KeyError: pass try: mac = network_info[netifaces.AF_PACKET][0]["addr"] except KeyError: mac = "NONE" format_dict['mac'] = mac if iface_up: format_dict.update(self.extract_network_info(network_info)) format_dict.update(self.extract_wireless_info(interface)) return format_dict
def do_mysql(): p = subprocess.Popen(['sudo','apt-get','install','mysql-server-5.5','-y']) p.wait() if p.returncode == 0: file_path = '/etc/mysql/my.cnf' shutil.copyfile(file_path,file_path + '.orig') replace_regex(file_path, 'bind-address', '#bind-address') p = subprocess.Popen(['sudo','service','mysql','restart']) p.wait() if p.returncode == 0: print 'MySql service restarted' mysql_pwd = raw_input("Enter mysql password for root user: "******" ","")) with con: cur = con.cursor() #cur.execute("CREATE USER 'kodi' IDENTIFIED BY 'kodi'") cur.execute("GRANT ALL ON *.* TO 'kodi'") ni.ifaddresses('eth0') ip = ni.ifaddresses('eth0')[2][0]['addr'] advancedsettings = advancedsettings_base.format(ip) with open('advancedsettings.xml', 'w') as fout: fout.write(advancedsettings) fout.close() p = subprocess.Popen(['sudo', 'mv', 'advancedsettings.xml', '/home/osmc/.kodi/userdata/' + 'advancedsettings.xml']) p.wait() if p.returncode == 0: return True return False
def get_iface_config(address): if not address: return None try: import netifaces except ImportError: raise AssertionError("netifaces module is not installed") pool = iptoint(address) for iface in netifaces.interfaces(): ifinfo = netifaces.ifaddresses(iface) if netifaces.AF_INET not in ifinfo: continue for inetinfo in netifaces.ifaddresses(iface)[netifaces.AF_INET]: addr_s = inetinfo.get('addr') netmask_s = inetinfo.get('netmask') if addr_s is None or netmask_s is None: continue addr = iptoint(addr_s) mask = iptoint(netmask_s) ip = addr & mask ip_client = pool & mask delta = ip ^ ip_client if not delta: config = { 'ifname': iface, 'server': inttoip(addr), 'net': inttoip(ip), 'mask': inttoip(mask) } return config return None
def GetSrcIPAddr(AF): if not AF: return None AddrList = [] for interface in netifaces.interfaces(): if netifaces.ifaddresses(interface): if AF in netifaces.ifaddresses(interface): for ipaddr in netifaces.ifaddresses(interface)[AF]: CurrentIPitem = ipaddress.ip_address(ipaddr['addr'].rsplit('%',1)[0]) if not CurrentIPitem.is_loopback and \ not CurrentIPitem.is_link_local and \ not CurrentIPitem.is_multicast and \ not CurrentIPitem.is_unspecified and \ not CurrentIPitem.is_reserved: AddrList.append(ipaddr['addr']) if AddrList: return ipaddress.ip_address(AddrList[0]) #Just Return the first Usable IP else: return None
def _detect(self): """uses the netifaces module to detect ifconfig information""" theip = None try: if self.opts['family'] == 'INET6': addrlist = netifaces.ifaddresses(self.opts['iface'])[netifaces.AF_INET6] else: addrlist = netifaces.ifaddresses(self.opts['iface'])[netifaces.AF_INET] except ValueError as exc: log.error("netifaces choked while trying to get network interface" " information for interface '%s'", self.opts['iface'], exc_info=exc) else: # now we have a list of addresses as returned by netifaces for pair in addrlist: try: detip = IPy.IP(pair['addr']) except (TypeError, ValueError) as exc: log.debug("Found invalid IP '%s' on interface '%s'!?", pair['addr'], self.opts['iface'], exc_info=exc) continue if self.netmask is not None: if detip in self.netmask: theip = pair['addr'] else: continue else: theip = pair['addr'] break # we use the first IP found # theip can still be None at this point! self.set_current_value(theip) return theip
def get_Eth0(): ''' We want to ensure we only listen on internal IP which is protected from the outside world ''' ni.ifaddresses('eth0') ip = ni.ifaddresses('eth0')[2][0]['addr'] return(ip)
def __init__(self): # ----------------- NIC INFO ----------------- self.os = platform.dist()[0] # If system is "debian": if self.os == 'debian': self.hostname = socket.gethostname() self.iface = ni.interfaces()[1] self.ipaddress = ni.ifaddresses(self.iface)[ni.AF_INET][0]['addr'] self.subnet = ni.ifaddresses(self.iface)[ni.AF_INET][0]['netmask'] self.gateways = ni.gateways()['default'][ni.AF_INET][0] # --- OS INFO --------------------- self.os_ver = platform.dist()[1] self.mac = ''.join('%012x' % get_mac()) self.ip_data = get_ip() self.path_ip = '/etc/network/interfaces' self.dns_file = '/etc/resolv.conf' # If system is "Arch Linux": else: self.hostname = socket.gethostname() self.iface = ni.interfaces()[1] self.ipaddress = ni.ifaddresses(self.iface)[ni.AF_INET][0]['addr'] self.subnet = ni.ifaddresses(self.iface)[ni.AF_INET][0]['netmask'] self.gateways = ni.gateways()['default'][ni.AF_INET][0] # --- OS INFO --------------------- self.os_ver = platform.dist()[1] self.mac = ''.join('%012x' % get_mac()) self.ip_data = get_ip() self.path_ip = '/etc/netctl/eth0' self.dns_file = '/etc/resolv.conf' logger.debug('GET IP SETTING OK!')
def send(self, widget): if not self.iface: self.popup(gtk.MESSAGE_WARNING, 'You must select a network interface to send from!') return False if not self.protocol: self.popup(gtk.MESSAGE_WARNING, 'You must select a packet protocol!') return False if not self.target: self.popup(gtk.MESSAGE_WARNING, 'You must enter a {} address!'.format(self.lbl_ip.get_text())) return False if not is_ip(self.target): self.popup(gtk.MESSAGE_WARNING, '{} is not a valid IP address!'.format(self.target)) return False src_mac = ni.ifaddresses(self.iface)[ni.AF_LINK][0]['addr'] src_ip = ni.ifaddresses(self.iface)[ni.AF_INET][0]['addr'] dst_ip = self.target try: sock = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, socket.htons(0x0003)) sock.bind((self.iface, 0)) except: self.popup(gtk.MESSAGE_ERROR, 'Could not open raw socket for transmission!\n' + 'Are you running this with root privileges?') return False if self.protocol == PROTO_ARP: try: sock.sendall(str(create_arp(src_mac, src_ip, dst_ip))) except Exception, e: self.popup(gtk.MESSAGE_ERROR, 'Unable to send packet: {}'.format(e.message)) return False return True
def main(cfg): logger = logging.getLogger('Main') logger.info('Available interfaces: {}.'.format(', '.join(netifaces.interfaces()))) interface_name = cfg['node']['interface'] if interface_name is not None: if interface_name not in netifaces.interfaces(): logger.warn('There is no interface {}!'.format(interface_name)) return else: mac, broadcast_address = get_interface_mac_broadcast(netifaces.ifaddresses(interface_name)) if mac is None: logger.warn('MAC not found on interface {}!'.format(interface_name)) if broadcast_address is None: logger.warn('Broadcast address not found on interface {}!'.format(interface_name)) else: for interface_name in netifaces.interfaces(): if interface_name.startswith('lo'): continue mac, broadcast_address = get_interface_mac_broadcast(netifaces.ifaddresses(interface_name)) if mac is not None and broadcast_address is not None: break if interface_name is None: logger.warn('There is no available appropriate interfaces!') return logger.info('Used interface: {}. MAC: {}. Broadcast address: {}.'.format(interface_name, mac, broadcast_address)) mac = int(mac.replace(':', ''), 16) logger.info('Integer MAC: {}.'.format(mac)) run_visualization_server(mac, broadcast_address, cfg)
def find_ip(iface): if not iface or iface == "any": return ("0.0.0.0", "") if_ip4 = netifaces.ifaddresses(iface)[netifaces.AF_INET][0]["addr"] if_ip6 = netifaces.ifaddresses(iface)[netifaces.AF_INET6][0]["addr"] return (if_ip4, if_ip6)
def get_commotion_client_ip(): """Check interfaces for a valid commotion client IP address""" # Will interface impact commotion tests commotion_interfaces = {} commotion_client_ip = None # Raw list of interfaces # Could be rewritten as for __, iface in enumerate(ni.interfaces()) interfaces = ni.interfaces() for iface in interfaces: try: if ni.ifaddresses(iface)[2][0]['addr'].startswith('10.'): print(iface + " has a valid Commotion IP address: " \ + ni.ifaddresses(iface)[2][0]['addr']) commotion_client_ip = ni.ifaddresses(iface)[2][0]['addr'] else: commotion_interfaces[iface] = False print(iface + " not valid") except KeyError: commotion_interfaces[iface] = True print(iface + " has been disconnected") continue try: commotion_client_ip except (exceptions.CommotionIPError, KeyError) as args: print(args) # This should only return one thing. Move interfaces somewhere else! return commotion_interfaces, commotion_client_ip
def get_host_ip4_addresses(): ip_list = [] for interface in interfaces(): if AF_INET in ifaddresses(interface): for link in ifaddresses(interface)[AF_INET]: ip_list.append(link['addr']) return ip_list
def find_ip(iface): if not iface or iface == 'any': return ('0.0.0.0','') if_ip4 = netifaces.ifaddresses(iface)[netifaces.AF_INET][0]['addr'] if_ip6 = netifaces.ifaddresses(iface)[netifaces.AF_INET6][0]['addr'] return (if_ip4, if_ip6)
def update(self): """Update IP stats using the input method. Stats is dict """ # Reset stats self.reset() if self.input_method == 'local' and netifaces_tag: # Update stats using the netifaces lib try: if not 'freebsd' in sys.platform: default_gw = netifaces.gateways()['default'][netifaces.AF_INET] else: raise KeyError, 'On FreeBSD, Calling gateways would segfault' except KeyError: logger.debug("Can not grab the default gateway") else: try: self.stats['address'] = netifaces.ifaddresses(default_gw[1])[netifaces.AF_INET][0]['addr'] self.stats['mask'] = netifaces.ifaddresses(default_gw[1])[netifaces.AF_INET][0]['netmask'] self.stats['mask_cidr'] = self.ip_to_cidr(self.stats['mask']) if not 'freebsd' in sys.platform: self.stats['gateway'] = netifaces.gateways()['default'][netifaces.AF_INET][0] except KeyError as e: logger.debug("Can not grab IP information (%s)".format(e)) elif self.input_method == 'snmp': # Not implemented yet pass # Update the view self.update_views() return self.stats
def get_mac_addresses(ifname=None,ignore_nas=True,with_ip4=False): """By default ignore stuff like firewire""" try: import netifaces if ifname: info = netifaces.ifaddresses(ifname) return (( _unpack_mac(info.get(18)) or _unpack_mac(info.get(17)) ),) else: addresses = [] for ifce in netifaces.interfaces(): if_props = INTERFACES.get(ifce) or (False,False,False,False) if_addrs = netifaces.ifaddresses(ifce) #print ifce, if_addrs, if_props if ignore_nas and if_props[2]: continue if not if_props[1]: continue ip4 = if_addrs.get(2) ip6 = if_addrs.get(30) if with_ip4 and not ip4: continue mac = if_addrs.get(17) or if_addrs.get(18) if mac: addresses.append(_unpack_mac(mac)) return addresses except Exception, e: import uuid # bit primitive, and not stable on mac m = hex(uuid.getnode())[2:-1].zfill(12) return ( ':'.join((m[0:2],m[2:4],m[4:6],m[6:8],m[8:10],m[10:12])), )
def getIface(): for i in netifaces.interfaces(): try: MAC = netifaces.ifaddresses(i)[netifaces.AF_LINK][0]["addr"] except: MAC = "" try: IP = netifaces.ifaddresses(i)[netifaces.AF_INET][0]["addr"] except: IP = "" print str(i)+"|"+str(IP)+"|"+str(MAC)
def generate_network_list(): data = json.load(open(NODE_DATA_FILE)) node_pub_ip = [] node_pri_ip = [] hostname = socket.gethostname() node_pri_ip = data[hostname]['private'].split()[0] node_pub_ip = data[hostname]['public'].split()[0] cmd = 'netstat -ie | grep -B1 {} | head -n2'.format(node_pub_ip) public_string = commands.getoutput(cmd) intf_public = public_string.split()[0] intf_public = intf_public.split(':')[0] mask_public = netifaces.ifaddresses(intf_public)[2][0]['netmask'] pub_subnet_addr = str(IPNetwork('{}/{}'.format(node_pub_ip, mask_public)).cidr)[:-3] cmd = 'netstat -ie | grep -B1 {} | head -n2'.format(node_pri_ip) private_string = commands.getoutput(cmd) intf_private = private_string.split()[0] intf_private = intf_private.split(':')[0] mask_private = netifaces.ifaddresses(intf_private)[2][0]['netmask'] pri_subnet_addr = str(IPNetwork('{}/{}'.format(node_pri_ip, mask_private)).cidr)[:-3] network_string = '{}:{}:1,{}:{}:2'.format(intf_public, pub_subnet_addr, intf_private, pri_subnet_addr) return network_string
def main(): parser=argparse.ArgumentParser() parser.add_argument("interface") parser.add_argument("passwd") parser.add_argument("-v6","--ipv6",action="store_true",help="use ipv6 address") args=parser.parse_args() password=args.passwd local_addr='' broadcast_addr='' port=9890 so='' if args.ipv6: local_addr=netifaces.ifaddresses(args.interface)[netifaces.AF_INET6][0]['addr'] broadcast_addr=netifaces.ifaddresses(args.interface)[netifaces.AF_INET6][0]['broadcast'] so=socket.socket(socket.AF_INET6,socket.SOCK_DGRAM) so.setsockopt(socket.SOL_SOCKET,socket.SO_BROADCAST,1) so.bind(('::',port)) else: local_addr=netifaces.ifaddresses(args.interface)[netifaces.AF_INET][0]['addr'] broadcast_addr=netifaces.ifaddresses(args.interface)[netifaces.AF_INET][0]['broadcast'] so=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) so.setsockopt(socket.SOL_SOCKET,socket.SO_BROADCAST,1) so.bind(('0.0.0.0',port)) so.settimeout(5) message=local_addr+'|'+password so.sendto(message.encode('UTF-8'),(broadcast_addr,port)) so.recv(50) #clean up the echo of the package we just sent try: print("Raspberry Pi's IP address is {0}".format(so.recv(50).decode('UTF-8'))) except socket.timeout: print('No response. Maybe the password is wrong.\n') so.close()
def setUp(self): ''' To check and install dependencies for the test ''' smm = SoftwareManager() pkgs = ["ethtool", "net-tools"] detected_distro = distro.detect() if detected_distro.name == "Ubuntu": pkgs.extend(["openssh-client", "iputils-ping"]) elif detected_distro.name == "SuSE": pkgs.extend(["openssh", "iputils"]) else: pkgs.extend(["openssh-clients", "iputils"]) for pkg in pkgs: if not smm.check_installed(pkg) and not smm.install(pkg): self.cancel("%s package is need to test" % pkg) interfaces = netifaces.interfaces() interface = self.params.get("interface") if interface not in interfaces: self.cancel("%s interface is not available" % interface) mtu_list = self.params.get("size_val", default=1500) self.mtu_list = mtu_list.split() self.iface = interface self.peer = self.params.get("peer_ip") self.eth = "ethtool %s | grep 'Link detected:'" % self.iface self.eth_state = process.system_output(self.eth, shell=True) if AF_INET in netifaces.ifaddresses(self.iface): self.ip_set = netifaces.ifaddresses(self.iface)[AF_INET][0]['addr']
def Get_LocalIP(): try: import netifaces interfaces = netifaces.interfaces(); for str in interfaces: print(str) chosen_interface = input('Please Choose The Network Interface From List Above =>') if chosen_interface not in interfaces: print('Wrong Input. Please Choose From List.') Get_LocalIP() else: try: ip = netifaces.ifaddresses(chosen_interface)[netifaces.AF_INET][0]['addr'] if ip == None: print("Wrong Interface. Please Select Another One...") else: return netifaces.ifaddresses(chosen_interface)[netifaces.AF_INET][0]['addr'] except KeyError: print("Wrong Interface. Please Select Another One...") Get_LocalIP() except: exc_type, exc_value, exc_traceback = sys.exc_info() logging.error(repr(traceback.format_exception(exc_type, exc_value, exc_traceback))) raise
def update(self): """Update IP stats using the input method. Stats is dict """ # Reset stats self.reset() if self.input_method == 'local' and netifaces_tag: # Update stats using the netifaces lib try: default_gw = netifaces.gateways()['default'][netifaces.AF_INET] except (KeyError, AttributeError) as e: logger.debug("Cannot grab the default gateway ({0})".format(e)) else: try: self.stats['address'] = netifaces.ifaddresses(default_gw[1])[netifaces.AF_INET][0]['addr'] self.stats['mask'] = netifaces.ifaddresses(default_gw[1])[netifaces.AF_INET][0]['netmask'] self.stats['mask_cidr'] = self.ip_to_cidr(self.stats['mask']) self.stats['gateway'] = netifaces.gateways()['default'][netifaces.AF_INET][0] except (KeyError, AttributeError) as e: logger.debug("Cannot grab IP information: {0}".format(e)) elif self.input_method == 'snmp': # Not implemented yet pass # Update the view self.update_views() return self.stats
def ip_addresses(): """Find the IP addresses of the divices that look at file. TODO: Make code so that when any divice is looking for data logalyzer can find ip address and email to device, if the ip address is seen multiple times then anotheremail is not sent to device. Returns: ip_list: the list with the ip addresses """ # list for ip addresses ip_list = [] # Interate over available interfaces for interface in netifaces.interfaces(): # Ignore interfaces with no data if bool(netifaces.ifaddresses(interface)) is False: continue # IPv4 addresses ALWAYS have a key of netifaces.AF_INET (2) # Make sure this is the case for this interface if netifaces.AF_INET in netifaces.ifaddresses(interface): # Hooray we have an IPv4 address! Add it to the list for interface_data in netifaces.ifaddresses( interface)[netifaces.AF_INET]: ip_list.append(interface_data['addr']) # Return return ip_list
def get_ip(self): interface = ni.gateways()['default'][ni.AF_INET][1] ni.ifaddresses(interface) ip = ni.ifaddresses(interface)[ni.AF_INET][0]['addr'] return str(ip)
def multiInterface(self): """ Creates a client socket for each network interface on a multihomed linux machine. Program will use each socket to send file segments across different network pathes. """ self.ifaces = [ elem for elem in self.ifaces if elem[0:3] == "eth" or elem[0:4] == "wlan" ] # parses interface list for network adapters if len( self.ifaces ) == 0: # if there are no available network adapters on host, exit program print( "No network interfaces available to send traffic. Exiting program...... " ) sys.exit() elif len( self.ifaces ) == 1: # if there is only one available network adapter on host, ask to continue print( "Only one adapter available to send traffic. MPTCP NOT GUARANTEED! Do you wish to continue (Y/N)?" ) a = True while ( a ): # continue to ask for a valid answer (Y/N) until it is given by user cont = str(raw_input("Answer (Y/N): ")) if cont == 'Y': a = False elif cont == 'N': sys.exit() # continue program normally if neither of the above conditions are met (interfaces >= 2) j = 0 for i in self.ifaces: # create a socket for each available network adapter and connects them to recieve node networkFile = open('/sys/class/net/' + str(i) + '/operstate', 'r') # checks if an interface is active ethStat = networkFile.read(2) if ethStat == 'up': try: self.socketsList.append( socket.socket( socket.AF_INET, socket.SOCK_STREAM)) # create client socket except socket.error, msg: print("Failed to create socket. Error code: " + str(msg[0]) + " , Error message: " + msg[1]) sys.exit() binder = netifaces.ifaddresses(i)[2][0][ 'addr'] # find ip address of network adapter self.socketsList[j].bind( (binder, 0)) # bind socket to network adapter try: self.socketsList[j].connect( (self.ipAddr, self.port)) # connects each socket to recieve node except socket.error: print("Could not connect to the destination node") sys.exit() print("Socket %d successfully connected!" % j) j = j + 1 networkFile.close()
def discover_machine(args): if args.ip is None: addrs = netifaces.ifaddresses("eth0") args.ip = addrs[netifaces.AF_INET][0]["addr"] if args.machine_name is None: args.machine_name = socket.gethostname()
def get_host_ip(): gws = ni.gateways() interface = gws["default"][ni.AF_INET][1] return ni.ifaddresses(interface)[ni.AF_INET][0]["addr"]
import subprocess import os from bs4 import BeautifulSoup import netifaces from netaddr import IPAddress def add_spaces(total_length, covered): return ' ' * (total_length - len(covered)) interface = netifaces.gateways()[netifaces.AF_INET][0][1] network_address = netifaces.ifaddresses(interface)[netifaces.AF_INET][0]['addr'] netmask = netifaces.ifaddresses(interface)[netifaces.AF_INET][0]['netmask'] network = network_address + '/' + str(IPAddress(netmask).netmask_bits()) print '[*] Scanning network...' print '[*] interface: {}, network: {}'.format(interface, network) proc = subprocess.Popen(['sudo', 'nmap', '-oX', '-', '-sn', '-PS21,22,25,3389', network], stdout=subprocess.PIPE, preexec_fn=os.setpgrp) nmap_output = proc.communicate()[0] print 'Hostname{}|IPv4{}|MAC{}|Vendor'.format( add_spaces(30, 'Hostname'), add_spaces(18, 'IPv4'), add_spaces(20, 'MAC') ) print 85 * '-' other_list = [] soup = BeautifulSoup(nmap_output, 'html.parser') for host in soup.findAll('host'):
DAT_LOC = 0x18000000 #Memory address of data location DAT_SIZE = 0x00800000 #Size of each individual buffer A_X_POS = 0 #Position of A_X data (DAT_LOC+A_X_POS*DAT_SIZE) A_Y_POS = 1 A_AMP_POS = 2 A_PH_POS = 3 B_X_POS = 4 B_Y_POS = 5 B_AMP_POS = 6 B_PH_POS = 7 TOT_DAT = 8 #Total number of data outputs NUM_BYTES = 4 #Bytes per point # get ip address to bind to ip = ni.ifaddresses('eth0')[2][1]['addr'] print ip HOST = ip #"137.205.214.123" PORT = 1004 PORT2 = 1002 # bind to port s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) #s2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) #s2.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) print "Sockets Created" s.bind((HOST, PORT)) #s2.bind((HOST, PORT2)) print "Socket Binds Complete"
def setUp(self): """ Setup and install dependencies for the test. """ self.test_name = "dapltest" self.hprm = self.params.get("HOST_PARAM", default="None") self.pprm = self.params.get("PEER_PARAM", default="None") if self.hprm == "None" and self.pprm == "None": self.cancel("No PARAM given") if process.system("ibstat", shell=True, ignore_status=True) != 0: self.cancel("MOFED is not installed. Skipping") detected_distro = distro.detect() pkgs = [] smm = SoftwareManager() if detected_distro.name == "Ubuntu": pkgs.extend(["openssh-client", "iputils-ping"]) elif detected_distro.name == "SuSE": pkgs.extend(["openssh", "iputils"]) else: pkgs.extend(["openssh-clients", "iputils"]) for pkg in pkgs: if not smm.check_installed(pkg) and not smm.install(pkg): self.cancel("Not able to install %s" % pkg) interfaces = netifaces.interfaces() self.dpl_int = self.params.get("dapl_interface", default="") self.dpl_peer = self.params.get("dapl_peer_interface", default="") self.hprm = self.hprm.replace('$dapl_interface', self.dpl_int) self.pprm = self.pprm.replace('$dapl_peer_interface', self.dpl_peer) self.iface = self.params.get("interface", default="") self.peer_ip = self.params.get("peer_ip", default="") self.hprm = self.hprm.replace('$peer_ip', self.peer_ip) self.peer_user = self.params.get("peer_user", default="root") self.peer_public_ip = self.params.get("peer_public_ip", default="") self.peer_password = self.params.get("peer_password", '*', default="None") self.ipaddr = self.params.get("host_ip", default="") self.netmask = self.params.get("netmask", default="") local = LocalHost() self.timeout = "2m" self.session = Session(self.peer_ip, user=self.peer_user, password=self.peer_password) if not self.session.connect(): self.cancel("failed connecting to peer") if self.iface[0:2] == 'ib': self.networkinterface = NetworkInterface(self.iface, local, if_type='Infiniband') try: self.networkinterface.add_ipaddr(self.ipaddr, self.netmask) self.networkinterface.save(self.ipaddr, self.netmask) except Exception: self.networkinterface.save(self.ipaddr, self.netmask) else: self.networkinterface = NetworkInterface(self.iface, local) try: self.networkinterface.add_ipaddr(self.ipaddr, self.netmask) self.networkinterface.save(self.ipaddr, self.netmask) except Exception: self.networkinterface.save(self.ipaddr, self.netmask) self.networkinterface.bring_up() if self.iface not in interfaces: self.cancel("%s interface is not available" % self.iface) if self.peer_ip == "": self.cancel("%s peer machine is not available" % self.peer_ip) self.local_ip = netifaces.ifaddresses(self.iface)[AF_INET][0]['addr'] self.mtu = self.params.get("mtu", default=1500) self.remotehost = RemoteHost(self.peer_ip, self.peer_user, password=self.peer_password) self.peer_interface = self.remotehost.get_interface_by_ipaddr( self.peer_ip).name self.peer_networkinterface = NetworkInterface(self.peer_interface, self.remotehost) self.remotehost_public = RemoteHost(self.peer_public_ip, self.peer_user, password=self.peer_password) self.peer_public_networkinterface = NetworkInterface( self.peer_interface, self.remotehost_public) if detected_distro.name == "Ubuntu": cmd = "service ufw stop" # FIXME: "redhat" as the distro name for RHEL is deprecated # on Avocado versions >= 50.0. This is a temporary compatibility # enabler for older runners, but should be removed soon elif detected_distro.name in ['rhel', 'fedora', 'redhat']: cmd = "systemctl stop firewalld" elif detected_distro.name == "SuSE": if detected_distro.version == 15: cmd = "systemctl stop firewalld" else: cmd = "rcSuSEfirewall2 stop" elif detected_distro.name == "centos": cmd = "service iptables stop" else: self.cancel("Distro not supported") if process.system(cmd, ignore_status=True, shell=True) != 0: self.cancel("Unable to disable firewall") output = self.session.cmd(cmd) if not output.exit_status == 0: self.cancel("Unable to disable firewall on peer") if self.peer_networkinterface.set_mtu(self.mtu) is not None: self.fail("Failed to set mtu in peer") if self.networkinterface.set_mtu(self.mtu) is not None: self.fail("Failed to set mtu in host")
def run(self): time.sleep(3) #To let te server start before sending a request to it # Write the mobile API KEY to the DB with connection.cursor() as cursor: cursor.execute("DELETE FROM rest_framework_api_key_apikey") cursor.execute( "INSERT INTO rest_framework_api_key_apikey VALUES('1','','','mobile','ooXein0ZieZohfoh0phuCee0eeng6aomu6tei7le9eiHo4Fai0')" ) cursor.execute( "INSERT INTO rest_framework_api_key_apikey VALUES('2','','','pi','a677abfcc88c8126deedd719202e50922')" ) try: config_file = open('interface.config', 'r') interface = config_file.readline() interface = interface[:-1] config_file.close() except FileNotFoundError: interface = 'eth0' ni.ifaddresses(interface) ip = ni.ifaddresses(interface)[2][0]['addr'] print('Local IP Address for ' + interface + ': ' + ip) Terminal.objects.all().delete() Ticket.objects.all().delete() Event.objects.all().delete() Auditorium.objects.all().delete() # Post to Gestion website our ip address while not self.sendIPtoGestionWebsite(ip): pass # Query Gestion website for the terminal list while not self.obtainTerminalsFromGestionWebsite(ip): pass # IF no terminal in DB Query Gestion website for ticketsList tickets = Ticket.objects.raw('SELECT * FROM api_ticket') terminals = Terminal.objects.raw( 'SELECT * FROM api_terminal WHERE "status"="Connected"') for terminal in terminals: while self.sendIPtoPI(my_ip=ip, pi_ip=terminal.ipAddress): pass isMaster = False while len(list(tickets)) == 0: if len(list(terminals)) == 0 or isMaster: isMaster = True self.obtainTicketsFromGestionWebsite(ip) # Else Query first PI in the list for the tickets else: self.obtainTicketList(ipAddress=terminals[0].ipAddress) tickets = Ticket.objects.raw('SELECT * FROM api_ticket') main.have_receive_ticket = True print('System ready to perform') while True: if self.verifyEventIsClose(ip): print( '======================================== Event is close ========================================' ) print('Send log') self.sendValidationStats(ip) print('Done\nBack up DB') copyfile( 'gti525/db.sqlite3', 'gti525/db.backup.' + datetime.now().strftime('%Y-%m-%d_%H:%M:%S') + '.sqlite3') with connection.cursor() as cursor: cursor.execute("DELETE FROM api_mobilecommlog") print('Done') break else: time.sleep(10)
def main(): ap = ArgumentParser() g = ap.add_mutually_exclusive_group(required=True) g.add_argument("--iface", "-i", type=get_iface, help="Interface name/index") g.add_argument("--list", "-l", action="store_true", help="List available interfaces") ap.add_argument("--threads", "-t", type=int, default=1, help="Number of concurrent threads") ap.add_argument("--delay", "-d", type=float, default=1.0, help="Delay between messages per thread") ap.add_argument("--search", "-s", action="store_true", help="Search ONLY (do not exhaust scopes)") args = ap.parse_args() if args.list: from pprint import pprint if WINDOWS: pprint(IFACES) else: import netifaces ifaces = netifaces.interfaces() fmt = "{:<7} {}" print(fmt.format("NAME", "IP ADDRESS")) for iface in ifaces: ifaddrs = netifaces.ifaddresses(iface) for idx in ifaddrs: for ifaddr in ifaddrs[idx]: if 0 < len(ifaddr.get("netmask", "")) < 16: print(fmt.format(iface, ifaddr.get("addr"))) return # Create a request queue for handler packets rq = None if args.search else Queue() # Create a packet handler thread for the desired interface and a queue for requests Handler(args.iface, rq).start() # Skip handling DHCP Offers for search-only if not args.search: # Create a thread that responds to Offers with Requests Requester(args.iface, rq).start() # Create discover threads (somewhat unnecessary, just decrease the delay) for _ in range(args.threads): Discover(args.iface, delay=args.delay).start() while True: get_stop_event().wait(0.1)
def on_submit(self, event, params, vars=None): # Edição de um cliente if params[0] == 'dlgEdit': if vars.getvalue('action', '') == 'OK': ip = vars.getvalue('ip', '') mac = vars.getvalue('mac', '') app = vars.getvalue('app', '') ret = backend.Config(self.app).saveMachine(ip, mac, app) #if not ret: ERROR self._editing = None # Adicionar uma faixa DHCP elif params[0] == 'addFaixa': if vars.getvalue('action', '') == 'OK': ip_inicial = vars.getvalue('inicial', '') ip_final = vars.getvalue('final', '') apps = vars.getvalue('apps') retRange, retAPPS = backend.Config(self.app).setRangeLTSP( ip_inicial, ip_final, apps) if not retRange: if ip_inicial.strip() <> '' and ip_final.strip() <> '': self._msgError3 = 'Erro ao adicionar a faixa de IPs. '+\ 'A faixa adicionada não está na mesma '+\ 'faixa da rede do servidor.' self._editing = None self._tab = 1 # Configurar a interface do Servidor elif params[0] == "interface": if vars.getvalue('action', '') == 'cadastrar_servidor': iface = vars.getvalue('iface', 'none') try: ip = ni.ifaddresses(iface)[2][0]['addr'] except: ip = '' try: masc = ni.ifaddresses(iface)[2][0]['netmask'] except: masc = '' ret = backend.Config(self.app).setServer(ip, masc, iface) if not ret: self._msgError = 'A nova interface escolhida não está configurada.'+\ 'Vá primeiro ao módulo "Redes" e defina um IP e uma máscara.' self._tab = 0 # Adicionar um cliente elif params[0] == "clientes": self._tab = 1 if vars.getvalue('action', '') == 'addCliente': mac = vars.getvalue('clientMAC', 'none') ip = vars.getvalue('clientIP', 'none') app = vars.getvalue('clientAPP', 'none') ret = backend.Config(self.app).saveMachine(ip, mac, app) if not ret: self._msgError2 = 'ERRO: ou o MAC é inválido ou o IP não está na mesma rede de seu servidor.' return elif params[0] == "clientImage": if vars.getvalue('action', '') == 'criar_imagem': mirror = vars.getvalue('mirror', '') backend.Config(self.app).ltspBuildClient(mirror=mirror) self._tab = 2 elif params[0] == 'info': self._tab = 3 if vars.getvalue('action', '') == 'getInfoLTSP': self._infoLTSP = True
from netifaces import interfaces, ifaddresses, AF_INET for ifaceName in interfaces(): addresses = [i['addr'] for i in ifaddresses(ifaceName).setdefault(AF_INET, [{'addr':'No IP addr'}] )] print('%s: %s' % (ifaceName, ', '.join(addresses)))
#!/usr/bin/env python3 import netifaces print(netifaces.interfaces()) for i in netifaces.interfaces(): print('\n***********Details of Interface - ' + i + ' **********') try: print(netifaces.ifaddresses(i)[netifaces.AF_LINK][0]['addr']) print(netifaces.ifaddresses(i)[netifaces.AF_INET][0]['addr']) except: print('Could not collect adapter information')
def get_iface_addr(iface='eth0', inet_type='AF_INET', inc_aliases=False, fatal=True, exc_list=None): """Return the assigned IP address for a given interface, if any. :param iface: network interface on which address(es) are expected to be found. :param inet_type: inet address family :param inc_aliases: include alias interfaces in search :param fatal: if True, raise exception if address not found :param exc_list: list of addresses to ignore :return: list of ip addresses """ # Extract nic if passed /dev/ethX if '/' in iface: iface = iface.split('/')[-1] if not exc_list: exc_list = [] try: inet_num = getattr(netifaces, inet_type) except AttributeError: raise Exception("Unknown inet type '%s'" % str(inet_type)) interfaces = netifaces.interfaces() if inc_aliases: ifaces = [] for _iface in interfaces: if iface == _iface or _iface.split(':')[0] == iface: ifaces.append(_iface) if fatal and not ifaces: raise Exception("Invalid interface '%s'" % iface) ifaces.sort() else: if iface not in interfaces: if fatal: raise Exception("Interface '%s' not found " % (iface)) else: return [] else: ifaces = [iface] addresses = [] for netiface in ifaces: net_info = netifaces.ifaddresses(netiface) if inet_num in net_info: for entry in net_info[inet_num]: if 'addr' in entry and entry['addr'] not in exc_list: addresses.append(entry['addr']) if fatal and not addresses: raise Exception("Interface '%s' doesn't have any %s addresses." % (iface, inet_type)) return sorted(addresses)
import docopt import flask import netifaces import sys app = flask.app.Flask(__name__) options = docopt.docopt('''\ Serve static files using the Flask micro web framework. Prerequities: sudo apt-get install -y python-flask python-setuptools python-dev curl sudo easy_install pip virtualenv docopt netifaces Usage: {0} Example client stuff: curl http://{1}:5000/foo.tar.gz -o foo.tar.gz '''.format(sys.argv[0], netifaces.ifaddresses('eth0')[2][0]['addr'])) @app.route('/<filename>') def hello_world(filename): app.logger.info(filename) return open(filename).read() if __name__ == '__main__': app.run(host='0.0.0.0')
help="clear all bandwidth limits") group.add_argument("-g", "--get", action="store_true", help="get all connected devices in LAN") args = parser.parse_args() # check if interface is specified and exist in PC if args.device is None: parser.error("Please define an interface (--device <interface>)") elif args.device not in netifaces.interfaces(): parser.error("Invalid interface.") # get ip address and netmask of device device_interface = netifaces.ifaddresses(args.device)[netifaces.AF_INET][0] ip_address = device_interface['addr'] netmask = netmask_to_cidr(device_interface['netmask']) # validity check if (args.show or args.clear or args.get) and (args.ip or args.download or args.upload): parser.error("-s, -c, -g are standalone arguments") elif (args.show or args.clear or args.get) is False: if args.ip is None: parser.error( "Must include IP when throttling (0.0.0.0 for global throttling)") elif args.ip is not None: try: ip_network = ipaddress.ip_interface(args.ip + "/" + netmask).network
def get_ipv6_address(ifname): return ifaddresses(get_ifname(ifname))[AF_INET6][0]['addr']
def get_mac_address(): try: return netifaces.ifaddresses('eth0')[netifaces.AF_LINK][0]['addr'] except: return netifaces.ifaddresses('wlan0')[netifaces.AF_LINK][0]['addr']
0] sys.exit(1) file = sys.argv[1] # randomize incase we change payloads and browser caches path = "".join(choice(lowercase) for i in range(10)) path += ".jnlp" # interfaces ints = "" for i in ni.interfaces(): ints += "%s, " % i interface = raw_input("(+) select your interface: %s: " % ints[:-2]) # get the ip from the interface try: ip = ni.ifaddresses(interface)[2][0]['addr'] except: print "(-) no ip address associated with that interface!" sys.exit(1) print "jnlp://%s:9090/%s" % (ip, path) try: server = HTTPServer(('0.0.0.0', 9090), xxe) print '(+) starting xxe server...' print '(+) have someone with Java SE installed visit: http://%s:9090/' % ip server.serve_forever() except KeyboardInterrupt: print '(+) shutting down the web server' server.socket.close()
import cgi import cgitb; cgitb.enable() import multiprocessing import os from timeit import Timer import netifaces ifaces_list = netifaces.interfaces() ifaces = [] ifaces.append(ifaces_list[1]) ifaces.append(ifaces_list[2]) ifaces.append(ifaces_list[0]) ip = '' for iface in ifaces: #prefer eth if str(iface).find("eth") > -1 and netifaces.ifaddresses(iface).has_key(2) == True: ip = netifaces.ifaddresses(iface)[2][0]["addr"] break if str(iface).find("wlan") > -1 and netifaces.ifaddresses(iface).has_key(2) == True: ip = netifaces.ifaddresses(iface)[2][0]["addr"] break if str(iface).find("lo") > -1: ip = netifaces.ifaddresses(iface)[2][0]["addr"] break cpus_avail = str(multiprocessing.cpu_count()) log_dict = {} tmp_log = open("input/tmp.log","r").readlines() #lets put this in a dictionary log_dict = {}
def cleanup(): print "Cleaning up the stuff for shutdown" print "Closing Socket" s.close() print "Socket closed\nStopping motors" StopMotors() print "Motors stopped\nStopping GPIO" GPIO.cleanup() print "GPIO stopped\nEverything cleaned up\nGoodbye" atexit.register(cleanup) s.bind(('', 20010)) os.system("clear") ip = ni.ifaddresses('wlan0')[2][0]['addr'] print "Battlebot server ip: " + ip print "Starting Battlebot Server" print "Settings Servo's on neutral" servo.set_pwm(8, 0, GetServoValue(0)) servo.set_pwm(9, 0, GetServoValue(0)) if (len(sys.argv) > 1): calalt = sys.argv[1] calacc = sys.argv[2] calmag = sys.argv[3] calgyro = sys.argv[4] caltemp = sys.argv[5] else: calalt = True calacc = False
# import socket # import sys import netifaces as ni # # Create a TCP/IP socket # sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) ni.ifaddresses('wlp6s0') ip = ni.ifaddresses('wlp6s0')[ni.AF_INET][0]['addr'] print(ip) # should print "192.168.100.37" print(type(ip)) # should print "192.168.100.37" # # Bind the socket to the port # server_address = (ip, 8090) # print (sys.stderr, 'starting up on %s port %s' % server_address) # sock.bind(server_address) # # Listen for incoming connections # sock.listen(1) # while True: # # Wait for a connection # print(sys.stderr, 'waiting for a connection') # connection, client_address = sock.accept() # try: # print (sys.stderr, 'connection from', client_address) # # Receive the data in small chunks and retransmit it # while True: # data = connection.recv(1024) # print(sys.stderr, 'received "%s"' % data) # if not data:
def get_ip(): try: return netifaces.ifaddresses('eth0')[netifaces.AF_INET][0]['addr'] except: return netifaces.ifaddresses('wlan0')[netifaces.AF_INET][0]['addr']
def transfer(current_image): HOST = ni.ifaddresses('wlan0')[ni.AF_INET][0]['addr'] PORT = 6666 cnt = 0 connected_clients_sockets = [] server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) server_socket.bind((HOST, PORT)) server_socket.listen(10) connected_clients_sockets.append(server_socket) def recvall(sock, msgLen): msg = "" bytesRcvd = 0 while bytesRcvd < msgLen: chunk = sock.recv(msgLen - bytesRcvd) if chunk == "": break bytesRcvd += len(chunk) msg += chunk if "\r\n" in msg: break return msg while True: if cnt == 1: break read_sockets, write_sockets, error_sockets = select.select(connected_clients_sockets, [], []) for sock in read_sockets: if sock == server_socket: sockfd, client_address = server_socket.accept() connected_clients_sockets.append(sockfd) else: try: data = recvall(sock, 4096) if data: txt = data.strip() if txt == 'Receive': sock.sendall('Ok\r\n') elif txt == 'Size': with open(current_image, 'rb') as f: file_size = len(f1.read()) f.seek(0) file_size = '%s' % file_size sock.sendall('Size %s\r\n' % file_size) elif txt == 'image_data': with open(current_image, 'rb') as f2: image_data = f2.read() msg = '%send_of_image\r\n' % image_data sock.sendall(msg) elif txt == 'Finished': sock.close() connected_clients_sockets.remove(sock) cnt = cnt + 1 except: sock.close() connected_clients_sockets.remove(sock) continue server_socket.close()
# put the log file in /var/log c.JupyterHub.extra_log_file = '/var/log/jupyterhub.log' # use GitHub OAuthenticator for local users c.JupyterHub.authenticator_class = 'oauthenticator.LocalGitHubOAuthenticator' c.GitHubOAuthenticator.client_secret = '5362c66ccff1766756910fc6c506fba99623458c' c.GitHubOAuthenticator.oauth_callback_url = 'https://appsvr.asrc.cestm.albany.edu/hub/oauth_callback' c.GitHubOAuthenticator.client_id = 'e28b956b838b69ebffcf' # create system users that don't exist yet c.LocalAuthenticator.create_system_users = True # specify users and admin c.Authenticator.whitelist = {'xcite', 'arnold', 'mark',"arnoldas500"} c.Authenticator.admin_users = {'xcite', 'arnold', 'mark',"arnoldas500"} from dockerspawner import DockerSpawner \ c.JupyterHub.spawner_class = DockerSpawner \ \ # The Hub's API listens on localhost by default, # but docker containers can't see that. # Tell the Hub to listen on its docker network: import netifaces docker0 = netifaces.ifaddresses('docker0') docker0_ipv4 = docker0[netifaces.AF_INET][0] c.JupyterHub.hub_ip = docker0_ipv4['addr']
import subprocess import netifaces as ni import re import multiprocessing from multiprocessing import Process, Queue import os import time import fileinput import atexit import sys import socket import requests ##Change me if needed myip = ni.ifaddresses('tun0')[ni.AF_INET][0]['addr'] dirs = "/root/Desktop/" ##Stop changing shit here start = time.time() class bcolors: HEADER = '\033[95m' OKBLUE = '\033[94m' OKGREEN = '\033[92m' WARNING = '\033[93m' FAIL = '\033[91m' ENDC = '\033[0m'
print args if args.f is not None: f = open(args.f, 'r') for line in f: line = line.split() if len(line) != 2: continue hosts[line[1].strip()] = line[0].strip() f.close() print(hosts) try: s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_RAW) except socket.error, msg: print 'Socket could not be created. Error Code : ' + str(msg[0]) + ' Message ' + msg[1] sys.exit() if args.i is None: my_ip = ni.ifaddresses(conf.iface)[2][0]['addr'] else: my_ip = my_ip = ni.ifaddresses(args.i)[2][0]['addr'] sniff(iface=args.i, filter=args.expression, prn=dns_spoof, lfilter=lambda x: x.haslayer(DNSQR)) if __name__ == "__main__": main()
def _master_networks_gen(cls, ifaces): for iface in ifaces: iface_data = netifaces.ifaddresses(iface) if netifaces.AF_LINK in iface_data: yield netifaces.ifaddresses(iface)[netifaces.AF_LINK]
#!/usr/bin/env python3 import netifaces print(netifaces.interfaces()) for i in netifaces.interfaces(): print('\n********Details of Interface - ' + i + ' ************') try: print((netifaces.ifaddresses(i)[netifaces.AF_LINK] )[0]['addr']) # Prints the MAC address print((netifaces.ifaddresses(i)[netifaces.AF_INET] )[0]['addr']) # Prints the IP address except: print() # Print an error message
def showM(uItem): curM = netifaces.ifaddresses(uItem) try: ui.label_curent_MAC.setText(curM[netifaces.AF_LINK][0]['addr']) except KeyError: ui.label_curent_MAC.setText('No MAC available for ' + uItem)
def get_ipv6_address(interface): """ Return the ip address of the specified interface """ return netifaces.ifaddresses(interface)[netifaces.AF_INET6][0]['addr']