def __init__(self, name, sports="", dports="", include="", loginfo=""): """ Create new service object with string parameters sports -- source port specifications like "www/tcp dns/udp" dports -- destination port specifications include -- include rules for other services to be included/aliased loginfo -- reference line number for user error messages """ if name == "" or not Util.verify_name(name, servicename=True): raise PyromanException("service lacking a proper name: '%s' at %s" \ % (name, loginfo)) if Firewall.services.has_key(name): raise PyromanException( "Duplicate service specification: '%s' at %s" % (name, loginfo)) if sports == "" and dports == "" and include == "" and (name != "ANY"): raise PyromanException( "service specification invalid: '%s' at %s" % (name, loginfo)) self.name = name self.loginfo = loginfo try: self.sports = map(lambda p: Port(p), Util.splitter.split(sports)) self.dports = map(lambda p: Port(p), Util.splitter.split(dports)) except PortInvalidSpec, p: raise PyromanException("Service '%s' contains invalid port spec '%s' at %s: %s" \ % (name, p.spec, loginfo, p.err))
def parse_ryu_switches(self): ryu_switches = None with open(self.network_configuration.conf_path + "ryu_switches.json", "r") as in_file: ryu_switches = json.loads(in_file.read()) # Go through each node and grab the ryu_switches and the corresponding hosts associated with the switch for dpid in ryu_switches: # prepare a switch id switch_id = "s" + str(dpid) # Check to see if a switch with this id already exists in the graph, # if so grab it, otherwise create it sw = self.get_node_object(switch_id) if not sw: sw = Switch(switch_id, self) self.graph.add_node(switch_id, node_type="switch", sw=sw) self.switch_ids.append(switch_id) # Parse out the information about all the ports in the switch switch_ports = {} for port in ryu_switches[dpid]["ports"]: if port["port_no"] == 4294967294: continue if port["port_no"] == "LOCAL": continue switch_ports[int(port["port_no"])] = Port(sw, port_json=port) if (not ryu_switches[dpid]["ports"]): #import pdb; pdb.set_trace() ovs_sw = self.network_configuration.mininet_obj.get(switch_id) for intf in ovs_sw.intfList(): if intf.name != 'lo': new_port_obj = Port(sw, None, intf) switch_ports[new_port_obj.port_number] = new_port_obj sw.ports = switch_ports # Parse group table if one is available if "groups" in ryu_switches[dpid]: sw.group_table = GroupTable(sw, ryu_switches[dpid]["groups"]) # Parse all the flow tables and sort them by table_id in the list switch_flow_tables = [] for table_id in ryu_switches[dpid]["flow_tables"]: switch_flow_tables.append( FlowTable(sw, table_id, ryu_switches[dpid]["flow_tables"][table_id])) sw.flow_tables = sorted( switch_flow_tables, key=lambda flow_table: flow_table.table_id)
def setUp(self): # GIVEN self._devices = Devices() for dev_id in range(5): device=Device(dev_id, Port(), Port()) for idx in range(5): device.primary.assign(idx, NOTSET) device.secondary.assign(idx, NOTSET) self._devices.all.append(device)
def link_add_handler(self, event): """ populate link information from event argument, then create bidirectional link between two nodes. """ src_port = Port(port=event.link.src, neighbor=event.link.dst) dst_port = Port(port=event.link.dst, neighbor=event.link.src) # Create bidirectional link self.update_port_link(src_port.dpid, src_port) self.update_port_link(dst_port.dpid, dst_port)
def _add_port(devices_lst, ref_dev_id, ref_prim_port): """ Add/create a port to the reference device. If config entry is: * 1 then its a primary port * 0 then its a secondary port """ if ref_prim_port == 0 and not devices_lst[ref_dev_id].secondary: devices_lst[ref_dev_id].secondary = Port() if ref_prim_port == 1 and not devices_lst[ref_dev_id].primary: devices_lst[ref_dev_id].primary = Port()
def __init__(self, data, browser): profile = data['profile'] # # Setup the environment. # self.env = data self.env['redfish_base'] = '/redfish/v1' self.env['browser'] = browser # # Create a socket endpoint for all dead-ended ports. # self.dead_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.dead_address = socket.gethostbyname('127.0.0.1') self.dead_socket.bind((self.dead_address, Port.PORT_DEAD)) # # Create the ports for IO. # self.ports = [ None for i in range(profile['portStart'], profile['portEnd']) ] port_info = self.env['profile']['ports'] for src_port, dst_addr, dst_port, _, _ in self.env['remote']: if port_info[src_port]['State'] == 'Enabled': dst_uid = profile['ports'][src_port]['Remote']['UID'] self.ports[src_port] = Port(self, 'Enabled', src_port, dst_addr, dst_port, dst_uid) # # Create the ports which are not linked. This code will have them send packets to a dead address. # for i in range(profile['portStart'], profile['portEnd']): if not self.ports[i]: self.ports[i] = Port(self, 'Disabled', i, '127.0.0.1', -1, 0x0) # # Create the thread to run the ports. # self.thread = Thread(target=self.run, daemon=True) self.thread.start() # # Setup the underlying REDFish server. # self.server = RedfishServer(self) self.server.start()
def createPort(self, name, media_type, direction='in'): port = Port(name, media_type, direction) self.ports.append(port) self.prepareGeometryChange() port.setParentItem(self) self.arrangePorts() self.sizeBackground()
def setUp(self): # GIVEN device0 = Device(0, Port(), Port()) for idx in range(5): device0.primary.assign(idx, NOTSET) for idx in range(4, 7): device0.secondary.assign(idx, NOTSET) device1 = Device(1, Port(), Port()) for idx in range(5): device1.primary.assign(idx, NOTSET) for idx in range(3, 4): device1.secondary.assign(idx, NOTSET) self._devices = [device0, device1]
def createVlcContainer(self): port = Port() newPort = port.getNewPort() sp.getoutput( "sudo docker run -dit --device /dev/snd -p {}:3333 xpra_vlc:v4". format(newPort)) return newPort
def add_port(self, port_num, port_conf=None): # add port specific vlans or fall back to defaults port_conf = copy.copy(port_conf) if port_conf else {} port = self.ports.setdefault(port_num, Port(port_num, port_conf)) port_conf.setdefault('mirror', None) if port_conf['mirror'] is not None: from_port_num = port_conf['mirror'] self.mirror_from_port[from_port_num] = port_num # other configuration entries ignored. return # add native vlan port_conf.setdefault('native_vlan', None) if port_conf['native_vlan'] is not None: vid = port_conf['native_vlan'] if vid not in self.vlans: self.vlans[vid] = VLAN(vid) self.vlans[vid].untagged.append(self.ports[port_num]) # add vlans port_conf.setdefault('tagged_vlans', []) for vid in port_conf['tagged_vlans']: if vid not in self.vlans: self.vlans[vid] = VLAN(vid) self.vlans[vid].tagged.append(port) # add ACL port_conf.setdefault('acl_in', None) if port_conf['acl_in'] is not None: self.acl_in[port_num] = port_conf['acl_in']
def __init__(self, component_dict=None): """ The ``Component`` class represents a device. A component stores state individually for each instance and can be configured by passing in parameters using a structure that reprsents the state. Args: path (str): path to a model yaml file. """ self.name = None self.ports = [] # Load name from component data file if 'name' in component_dict: self.name = component_dict['name'] # Load host flag from component data file if 'host' in component_dict: self.host = component_dict['host'] else: self.host = False # Load ports from component data file for port_dict in component_dict['ports']: port = Port(self, port_dict) self.ports.append(port)
def start_tunnel(self): if self is not currentThread(): self._send_cmd('start') return self._op_lock.acquire() try: self.is_active = 1 # set up Port object for the tunnel that reads\writes to the # slave device file of the pseudo-terminal pair. if not self._serial_port: self._serial_port = Port() cfg = self._vcp.configuration() cfg['dev'] = self.tty cfg['name'] = '_slave' cfg['parent'] = self._vcp self._serial_port.configure(cfg) self._op_lock.release() except: self._op_lock.release() while self.is_active: if not self._serial_port.is_open(): self._serial_port.open() self._serial_port.drain() try: if self.is_server: self._do_listen() else: self._do_connect() except: msglog.exception() if self._serial_port and not self._serial_port.is_open(): self._serial_port.close()
def create_port_list(self, start_port): """ 创建可用端口 """ port = Port() port_list = port.create_port_list(start_port, self.device_list) return port_list
def get_suspicious(): recent_ip, recent_port = sniff_ip(TIME_TO_SNIFF) for ip_src in recent_ip: if not ip_src in IP_DICT.keys(): new_ip = IP(ip_src, TIME_TO_SNIFF) IP_DICT[ip_src] = new_ip IP_DICT[ip_src].add_count(recent_ip[ip_src]) for port_src in recent_port: if not port_src in PORT_DICT.keys(): new_port = Port(port_src, TIME_TO_SNIFF) PORT_DICT[port_src] = new_port PORT_DICT[port_src].add_count(recent_port[port_src]) for ip_src in IP_DICT: data = IP_DICT[ip_src].get_data() if data['velocity'] > SUSPICIOUS_VELOCITY or data[ 'acceleration'] > SUSPICIOUS_ACCELERATION: SUSPICIOUS_IPS.append(ip_src) for port_src in PORT_DICT: data = PORT_DICT[port_src].get_data() if data['velocity'] > SUSPICIOUS_VELOCITY or data[ 'acceleration'] > SUSPICIOUS_ACCELERATION: SUSPICIOUS_PORTS.append(port_src) return SUSPICIOUS_IPS, SUSPICIOUS_PORTS
def parse_sel_switches(self, sel_switches): for each_id, switch in sel_switches.iteritems(): # prepare the switch id switch_id = "s" + str(each_id) sw = self.get_node_object(switch_id) # Check to see if a switch with this id already exists in the graph, # if so grab it, otherwise create it if not sw: sw = Switch(switch_id, self) self.graph.add_node(switch_id, node_type="switch", sw=sw) self.switch_ids.append(switch_id) # Parse out the information about all the ports in the switch switch_ports = {} for port in switch["ports"]: switch_ports[port["portId"]] = Port(sw, port_json=port) sw.ports = switch_ports # Parse group table if one is available if "groups" in sel_switches[each_id]: sw.group_table = GroupTable(sw, sel_switches[each_id]["groups"]) # Parse all the flow tables and sort them by table_id in the list switch_flow_tables = [] for table_id in sel_switches[each_id]["flow_tables"]: switch_flow_tables.append( FlowTable(sw, table_id, sel_switches[each_id]["flow_tables"][table_id])) sw.flow_tables = sorted(switch_flow_tables, key=lambda flow_table: flow_table.table_id)
def porty_wstawianie(self): #wstawianie portow pomiedzy srodkami wskazanymi przed kandydatow wybrancy = self.porty_kandydaci() wybor = [i % 5 for i in range(len(wybrancy) // 5 * 5)] wybor += [5 for i in range(len(wybrancy) - len(wybor))] self.porty = [] #ustawienie tak, zeby porty nie staly na hexie surowca ktory wymieniaja for a in range(len(wybrancy)): i = wybrancy[a] temp = wybor.copy() for j in (i[0].sas_hexy + i[1].sas_hexy): if j.surowiec in temp: temp.remove(j.surowiec) if len(temp) == 0: print("Polegl port") temp = wybor.copy() ustawienie = choice(temp) wybor.remove(ustawienie) i[0].handel, i[1].handel = ustawienie, ustawienie #wstawienie portu na mapke self.porty.append(Port(ustawienie)) self.porty[a].setZValue(3) self.porty[a].setPos((i[0].pos().x() + i[1].pos().x()) // 2, (i[0].pos().y() + i[1].pos().y()) // 2) self.scene.addItem(self.porty[a])
def createContainer(self): port = Port() newPort = port.getNewPort() sp.getoutput( "sudo docker run -dit -p {}:3333 --device /dev/snd -v /videos:/root/video xpra_vlc:v4" .format(newPort)) return newPort
def create_port_list(self, start_port): ''' 创建可用端口 ''' port = Port() port_list = [] port_list = port.create_port_list(start_port, self.device_list) return port_list
def Place(self, seg): self.placed = True self.Go() segport = Port([Vertex(*pnt) for pnt in seg]) tmat = self.GetInport(self.innum).Overlay(segport) for prim in self.prims: prim.SelfTrans() self.Trans(tmat)
def enable_ports(self): for host, port in self.router.connections: new_port = Port(port=port, host=host) new_port_name = str(new_port) self.router.ports.update({new_port_name: new_port}) self.port_locks.update({new_port_name: RLock()}) for port in self.router.ports.keys(): self.get_up_port(port)
def add_port(self, name, is_output=False, flags=0, ptr=None): port = Port(self, self.scene()) port.set_is_output(is_output) port.set_name(name) port.set_node(node=self) port.set_port_flags(flags) port.set_ptr(ptr) self._ports.append(port)
def get_ports(self): """ Get all ports of this switch. Returns Port objects. """ from hpswitch.port import Port base_ports = self.snmp_get_subtree(("dot1dBasePort", )) return [Port(self, base_port=int(p[1])) for p in base_ports]
def EnumeratePorts(self): """Enumerate all storage ports on the system returns: An array of object paths for ports """ l = list() for i in self.iface.EnumeratePorts(): obj = Port(i) l.append(obj) return l
def addPort(self, portType=None, dataType=None, name=None): #Redefined # [ [portIN, portOUT], ... ] self._inputs.append( Port(dataType=dataType, portType="IN", name=name + "_IN", nodePointer=self)) portIN = self._inputs[-1] self._outputs.append( Port(dataType=dataType, portType="OUT", name=name + "_OUT", nodePointer=self)) portOUT = self._outputs[-1] self.addPair(portIN=portIN, portOUT=portOUT) return self._portsPairs[-1]
def ListPorts(Where=''): out = [] DbConnection = sqlite3.connect('main.db') DbCursor = DbConnection.cursor() #cursor=DbCursor.execute("SELECT * FROM PORTS "+Where) for row in DbCursor.execute("SELECT * FROM PORTS " + Where).fetchall(): Obj = Port() Obj.Id = row[0] Obj.RouterId = row[1] Obj.Ip = row[2] out.append(Obj) DbConnection.close() return out
def get_port_for_mac(self, mac): """ Returns the port that a specified mac is learned on, or None if no such port exists. """ oid = tuple([ 'dot1dTpFdbPort', ] + [int(x, 16) for x in mac.split(":")]) portID = self.snmp_get(oid) if not portID: return None port = Port(self, base_port=int(portID)) return port
def port_add_handler(self, event): """ event handler triggered when port added. get Swtich instance and creat a Port object. """ port = Port(event.port) try: switch = self.switches[port.dpid] switch.ports[port.port_no] = port logger.info('port added, port_no=%s (dpid=%s)', portno_lib.port_no_to_str(port.port_no), dpid_lib.dpid_to_str(port.dpid)) except: pass
def port_delete_handler(self, event): """ event handler triggered when port deleted. get Switch instance and delete specific Port object. """ port = Port(event.port) logger.info('port deleted, port_no=%s (dpid=%s)', portno_lib.port_no_to_str(port.port_no), dpid_lib.dpid_to_str(port.dpid)) try: switch = self.switches[port.dpid] del switch.ports[port.port_no] except KeyError: pass
def port_parser(dp_id, p_identifier, port_conf, vlans): port = Port(p_identifier, port_conf) if port.mirror is not None: # ignore other config return port if port.native_vlan is not None: v_identifier = port.native_vlan vlan = vlans.setdefault(v_identifier, VLAN(v_identifier, dp_id)) vlan.untagged.append(port) for v_identifier in port.tagged_vlans: vlan = vlans.setdefault(v_identifier, VLAN(v_identifier, dp_id)) vlan.tagged.append(port) return port
def port_parser(dp_id, p_identifier, port_conf, vlans): port = Port(p_identifier, port_conf) if port.mirror is not None: # ignore other config return port if port.native_vlan is not None: v_identifier = port.native_vlan vlan = _get_vlan_by_identifier(dp_id, v_identifier, vlans) vlan.add_untagged(port) for v_identifier in port.tagged_vlans: vlan = _get_vlan_by_identifier(dp_id, v_identifier, vlans) vlan.add_tagged(port) return port