def option1(): global ipsrc, ipdst iplist = [] os.system("clear") a = 1 print "Network interfaces & IPs" print "------------------------" for i in interfaces.interfaces(): print "%d. Interface name: " % a, i, ", IP: ", interfaces.interfaces()[i] iplist.append(interfaces.interfaces()[i]) a+=1 while True: out_int = raw_input("Output interface: ") try: ipsrc = iplist[int(out_int)-1] break except IndexError: print "Try again!" while True: in_int = raw_input("Input interface: ") if out_int <> in_int: try: ipdst = iplist[int(in_int) - 1] break except IndexError: print "Try again!" else: print "Try again!" print "________________________________________________________________\n" print "Source IP: ",ipsrc,"\n","Destination IP: ", ipdst raw_input("\nPress enter to return to main menu...")
def __init__(self, dst=None): # Get one's SRC IP & interface i = interfaces.interfaces() self.src = i[1][0] self.iface = i[0] self.netmask = i[1][1] self.enet = i[2] self.dst = dst sys.stderr.write("SIP IP %s, iface %s, netmask %s, enet %s\n" % (self.src, self.iface, self.netmask, self.enet)) # A queue where received packets go. If it is full # packets are dropped. self.packetQueue = Queue.Queue(100000) self.dropCount = 0 self.idcount = 0 self.ethrdst = "" # Get the destination ethernet address with an ARP self.arp() # You can add other stuff in here to, e.g. keep track of # outstanding ports, etc. # Start the packet sniffer t = threading.Thread(target=self.run_sniffer) t.daemon = True t.start() time.sleep(.1)
def main(): """ Execution begins here. """ ints = interfaces.interfaces() # Add Ethernet0/1, enable it, and place into VLAN 10 eth01 = ints.interface_container.switchport_list.add("Ethernet0/1") eth01.enabled = True eth01.vlan = 10 # Add Ethernet0/2, enable it, and place into VLAN 20 eth02 = ints.interface_container.switchport_list.add("Ethernet0/2") eth02.enabled = True eth02.vlan = 20 # Add Ethernet0/3, but try and set VLAN to 9999 eth03 = ints.interface_container.switchport_list.add("Ethernet0/3") try: print("Trying to set bogus VLAN 9999") eth03.vlan = 9999 except ValueError as exc: # This code always runs, since VLAN 9999 is never valid print(exc.args[0]["error-string"]) # Add Loopback0, enable it, and set an IP address lb0 = ints.interface_container.virtual_list.add("Loopback0") lb0.enabled = True lb0.ip_address = "192.0.2.1" # Add Loopback1, but leave all default values in place lb1 = ints.interface_container.virtual_list.add("Loopback1") # Print JSON representation of the current config print(json.dumps(ints.get(), indent=2))
def __init__(self,basedir=".",mode="initial",cores=-1): self.basedir = basedir self.mode = mode self.lastAcceptedPath = "start" if cores == -1: self.cores = multiprocessing.cpu_count() else: self.cores = cores self.wrapper = wrappers.gromacswrapper() self.distparser = parser.gdistparser() self.filesystem = filesystem.filesystem() self.interfaces = interfaces.interfaces() self.stablestates = stablestates.stablestates() self.helper = helpers.helpers() #Initialize the logger self.log = gtpslogging.log("debug",basedir) self.log.log.debug("logfile created") self.log.log.info(str(self.cores) + " CPUs detected") #read the stables states from a file self.stablestates.readStates(os.path.join(basedir,"stablestates.txt")) self.log.log.info("Read States : " + str(self.stablestates.states)) """ This array holds all the information about the paths. Each trajectory consists of a forward-part and a backward-part. The trajectory can either be a forward trajectory or a backward trajectory. Forward trajectroies start in A. """ self.paths = [] self.paths.append(pathsimulation.pathdata(0,basedir,mode,forward=True,forwardpart=True)) self.paths.append(pathsimulation.pathdata(0,basedir,mode,forward=True,forwardpart=False))
def main(): mainLogger = logger.logger("main") mainLogger.log.info("Starting main") mainInterfaces = interfaces.interfaces() openInterfaces(mainInterfaces) mainDataManager = dataManager.dataManager(interfaces=mainInterfaces) ######## GENERATE FAKE DATA DONT FORGET TO REMOVE THIS ##################### # mainDataManager.genFakeData() ############################################################################ axLogPath = "/logs/axlisten.log" ground = groundComms.groundComms(axLogPath=axLogPath, interfaces=mainInterfaces, dataManager=mainDataManager) mainInterfaces.gpio.setPinMode(pin=18, mode=mainInterfaces.gpio.OUTPUT) # Status LED # Schedule tasks mainScheduler = scheduler.scheduler() mainScheduler.schedule(callback=mainDataManager.setTimeSync, frequency=20) mainScheduler.schedule(callback=mainDataManager.log, frequency=3) mainScheduler.schedule(callback=ground.streamTelemetry, frequency=10) mainScheduler.schedule(callback=mainInterfaces.habip_osd.cycle, frequency=20) # Set OSD header because fun header = "{} RIT TEAM HABIP {}".format(mainInterfaces.osd232.symbol["satellite"], mainInterfaces.osd232.symbol["heart"]) mainInterfaces.habip_osd.header = header run = True while run: mainInterfaces.watchdog.pet() # Pet the watchdog mainInterfaces.gpio.toggleOutput(18) # Status LED ground.update() ground.executeCommands(withDelay=100) mainDataManager.update() mainInterfaces.daqcs.update() mainScheduler.update() mainInterfaces.habip_osd.update_all() # This takes about a second to process # print mainInterfaces.habip_osd.osd232.preview() # for name, board in mainInterfaces.boards.iteritems(): # print "Data for board: {}".format(name) # board.printAllData() mainLogger.log.info("main loop terminating")
def __init__(self, api_key, api_url, local_hostname, configured_interfaces): """Initialize dnsupdate""" # Pull configuration from config_settings self.api_key = api_key self.local_hostname = local_hostname self.configured_interfaces = configured_interfaces self.interface = interfaces.interfaces(self.configured_interfaces) self.prev_addresses = [ ipaddress.ip_address('127.0.0.1'), ipaddress.ip_address('::1') ] # Set up http_accessor object. try: self.dreamhost_accessor = http_access.http_access(api_url) except KeyError as error: logging.critical("Could not set up DreamHost API communications. Error: %s" % (error))
def __init__(self, api_key, api_url, local_hostname, configured_interfaces, bExternal, external_url, previous_v4_address, previous_v6_address): """Initialize dnsupdate""" # Pull configuration from config_settings self.api_key = api_key self.local_hostname = local_hostname self.configured_interfaces = configured_interfaces self.use_external = bExternal self.interface = interfaces.interfaces(self.configured_interfaces) self.previous_v4_address = ipaddress.ip_address(previous_v4_address) self.previous_v6_address = ipaddress.ip_address(previous_v6_address) self.prev_addresses = [ self.previous_v4_address, self.previous_v6_address ] if self.use_external: if logging.getLogger().getEffectiveLevel() == logging.INFO: logging.getLogger("requests").setLevel(logging.WARNING) try: response = requests.request('GET', external_url) if response.status_code == 200: self.external_ip = ipaddress.ip_address(response.text) if self.external_ip.version == 4: logging.info("External IP address detected as: %s" % (self.external_ip)) else: logging.critical("Error retrieving external IP. Response: %s" % (response.text)) sys.exit() else: logging.critical("Could not access external url. Status code: %s" % (response.status_code)) sys.exit() except: logging.critical("Could not access external url: %s" % (external_url)) sys.exit() if logging.getLogger().getEffectiveLevel() == logging.INFO: logging.getLogger("requests").setLevel(logging.getLogger().getEffectiveLevel()) # Set up http_accessor object. try: self.dreamhost_accessor = http_access.http_access(api_url) except KeyError as error: logging.critical("Could not set up DreamHost API communications. Error: %s" % (error)) sys.exit()
def __init__(self, dst=None): # get source ip and interface i = interfaces.interfaces() self.src = i[1][0] self.iface = i[0] self.netmask = i[1][1] self.enet = i[2] self.dst = dst sys.stderr.write("SIP IP %s, iface %s, netmask %s, enet %s\n" % (self.src, self.iface, self.netmask, self.enet)) # packet queue self.packetQueue = Queue.Queue(100000) self.dropCount = 0 self.idcount = 0 self.ethrdst = "" # arp request for the address self.arp() # Start the packet sniffer t = threading.Thread(target=self.run_sniffer) t.daemon = True t.start() time.sleep(.1)
def main(): intf = interfaces.interfaces() intf.openspi() intf.opendaqcs() d = intf.daqcs while True: print "----------" print d.currentState # d.queueCommand("{06:1491592543}") # d.queueCommand("{05:B0}") # d.queueCommand("{06:1491592543}") d.update() for name, board in intf.boards.iteritems(): print "Data for board: {}".format(name) board.printAllData() common.msleep(3000)
def main(): ints = interfaces.interfaces() eth01 = ints.interface_container.switchport_list.add("Ethernet0/1") eth01.enabled = True eth01.vlan = 10 eth02 = ints.interface_container.switchport_list.add("Ethernet0/2") eth02.enabled = True eth02.vlan = 10 eth03 = ints.interface_container.switchport_list.add("Ethernet0/3") try: print("Trying to set bogus VLAN 9999") eth03.vlan = 9999 except ValueError as exc: print(exc.args[0]['error-string']) lb0 = ints.interface_container.virtual_list.add("Loopback0") lb0.enabled = True lb0.ip_address = "192.0.2.1" lb1 = ints.interface_container.virtual_list.add("Loopback1") print(json.dumps(ints.get(), indent=2))
#!/usr/bin/env python import axreader import interfaces import common import groundComms ################################# Unit Testing ################################# if __name__ == "__main__": LOG_PATH = "/home/pi/axlisten.log" i = interfaces.interfaces() i.openbeacon() gc = groundComms.groundComms(axLogPath=LOG_PATH, interfaces=i) # reader = axreader.axreader(filePath=LOG_PATH, interfaces=AX_INTERFACES, sources=AX_SOURCES, destinations=AX_DESTINATIONS) # while False: while True: # Get packets from axreader gc.update() # for packet in packets: # print packet # print "--------" # # Parse the commands # gc.parseCommands(packet.data)
''' Created on 05/08/2013 @author: Alejandra ''' import arbol import interfaces if __name__ == '__main__': pass # myclass=arbol.arbol() # myclass.action() inter= interfaces.interfaces() inter.interaction() # inter.all()
) parser.add_argument( 'kwargs', action='store', help='Args: key1=value1,key2=value2...keyn=valuen', nargs='?') return parser.parse_args(args) if __name__ == '__main__': index = sys.argv.index('rm') if 'rm' in sys.argv else\ sys.argv.index('list') if 'list' in sys.argv else\ sys.argv.index('add') if 'add' in sys.argv else len(sys.argv) ms = mainparser(sys.argv[1:(index+1)]) os = secondaryparser(sys.argv[index+1:], ms.command) intfile = interfaces(ms.input) if ms.command == 'list': if ms.verbose: print 'List command applied' ms.output = "-" elif ms.command == 'add': if ms.verbose: print 'Add command applied' kw = dict() if not os.kwargs else\ dict(i.split('=') for i in os.kwargs.split(',')) if ms.verbose: print 'kwargs parsed: %s' % str(kw) if os.type == 'loopback': wizards.addloopback(intfile, ms.verbose, **kw) if os.type == 'device':
def __init__(self,basedir=".",mode="initial",kernel=0): self.basedir = basedir self.mode = mode self.cores = multiprocessing.cpu_count() self.wrapper = wrappers.gromacswrapper() self.distparser = parser.gdistparser() self.filesystem = filesystem.filesystem() self.interfaces = interfaces.interfaces() self.orderparameters = orderparameters.orderparameters() self.helper = helpers.helpers() self.kernels = kernels.kernels(kernel) self.qsubsystem = qsubsystem.qsubsystem() #Initialize the logger if kernel=="head": self.log = gtpslogging.log("info",basedir,kernel) elif kernel=="reverse": self.log = gtpslogging.log("info",basedir,kernel) else: self.log = gtpslogging.log("info",basedir,kernel) self.log.log.debug("logfile created") self.log.log.info(str(self.cores) + " CPUs detected") self.interfaces.readInterfaces(os.path.join(basedir,"options","interfaces.txt")) self.log.log.info("Read Interfaces Forward : " + str(self.interfaces.interfaces[0])) self.log.log.info("Read Interfaces Backward : " + str(self.interfaces.interfaces[1])) self.kernels.readKernelOptions(os.path.join(basedir,"options","kerneloptions.txt")) #read the stables states from a file self.orderparameters.readOP(os.path.join(basedir,"options","orderparameters.txt")) self.log.log.info("Read OP : " + str(self.orderparameters.op[0])) """ This array holds all the information about the paths. Each trajectory consists of a forward-part and a backward-part. The trajectory can either be a forward trajectory or a backward trajectory. Forward trajectroies start in A. """ self.paths = [] self.npaths = 0 for i in range(self.interfaces.ninterfaces[0]): self.paths.append(pathdata.pathdata(i,basedir,mode,forward=True,forwardpart=True,interface=self.interfaces.interfaces[0][i])) self.paths.append(pathdata.pathdata(i,basedir,mode,forward=True,forwardpart=False,interface=self.interfaces.interfaces[0][i])) self.npaths += 1 for i in range(self.interfaces.ninterfaces[1]): n = i + self.interfaces.ninterfaces[0] self.paths.append(pathdata.pathdata(n,basedir,mode,forward=False,forwardpart=True,interface=self.interfaces.interfaces[1][i])) self.paths.append(pathdata.pathdata(n,basedir,mode,forward=False,forwardpart=False,interface=self.interfaces.interfaces[1][i])) self.npaths += 1 self.reversePaths = [] for rp in self.interfaces.reversepaths[0]: self.reversePaths.append(pathdatareverse.pathdatareverse(0, basedir, mode, forward=True, forwardpart=True, interface=rp, state=0)) for rp in self.interfaces.reversepaths[1]: self.reversePaths.append(pathdatareverse.pathdatareverse(0, basedir, mode, forward=True, forwardpart=True, interface=rp, state=1)) self.kernels.generateKernelLists(self.npaths) self.interfacedir = int(float(self.paths[0].options.runoptions["interfacecoordinate"])) print self.interfacedir