def run(self):
self.logger.info("Starting sequence 1")
if len(self.output_ports) == 0:
self.logger.info("There are no ports in the ICD satisfying the " \
"scripts criteria")
return
self.sendRSET()
for port in self.output_ports:
if port.port_characteristic == PORT_SAP:
cmd = ESAP(port)
setattr(port, "ip_dst", get("TE_IP"))
setattr(port, "udp_dst", int(get("TE_UDP")))
else:
#cmd = EIPC(port)
cmd = ESAP(port)
command_size = cmd.command_size
message = "Short message"
messages = []
messages.append(buildShortMessage(port, message, command_size))
messages.append(buildMessage(port,
(int(port.buffer_size)/2) - command_size,
message))
messages.append(buildMessage(port,
int(port.buffer_size) - command_size,
message))
for message in messages:
command = cmd.buildCommand(command = 'SEND', message = message)
self.send(command, Factory.GET_TX_Port())
if not pollForResponse(("OK", "ERR")):
self.logger.info("The ES did not respond to EIPC command")
def start(self):
if not os.path.exists(CAPTURES_PARENT_DIRECTORY):
self.logger.error("The directory %s does not exist" % \
CAPTURES_PARENT_DIRECTORY)
return
count = 0
for file in glob.glob(os.path.join(CAPTURES_PARENT_DIRECTORY,
"*.cap")):
self.logger.info("%s Starting analysis for capture %s %s" %
("=" * 5, file, "=" * 5))
self.reader = PcapReader(file)
self.src_ip = get("TE_IP")
self.dst_ip = get("TR_IP")
global APPLICATION_CODES
packets = self.reader.read_all()
fragd, defragd, _ = defrag(packets)
packets = fragd + defragd
for packet in packets:
if packet.haslayer(Raw):
for code in APPLICATION_CODES:
if code in str(packet[Raw]):
self.printPacketDetails(packet, code)
count += 1
if count == 0:
self.logger.warn("There are no capture files in directory : %s" % \
CAPTURES_PARENT_DIRECTORY)
else:
self.logger.info("Successfully analyzed %d capture%s" % \
(count, "s" if count > 1 else ""))
print "Please check the log file %s at %s for the analyzer report" \
% (self.log_filename, LOGGER_PARENT_DIRECTORY)
def filter(port):
if str(port.vl_id) == get('TE_TX_VL') and \
port.port_characteristic != PORT_SAMPLING and \
port.network_id != NETWORK_B:
port.ip_dst = get('TR_IP')
return True
return False
def __addEthernetDetails(self):
eth = Ether()
src_mac_padding = '%04x' % self.__port.vl_id
eth.dst = "%s:%s:%s" % (get("MAC_PREFIX_RX"),
src_mac_padding[:2],
src_mac_padding[2:])
eth.src = get("MAC_PREFIX_TX") + ":20"
eth.type = 0x800
self.__packet = eth
def sequence1(self):
self.captureForSequence(1)
msg_8kb = buildStaticMessage(8192, "Message size = 8192")
msg_64kb = buildStaticMessage(64 * 1024, "Message size = 65536")
msg = "ping test"
msgs = [msg_8kb, msg_64kb, msg]
for port in self.icmp_ports:
setattr(port, 'ip_src', get("NMF_IP"))
self.logger.info("Sending an ICMP from NMF ip : %s" % get("NMF_IP"))
for msg in msgs:
self.sendICMP(port, msg, False)
def transmit_packets(self, packets, network):
for packet in packets:
packet = self.__addPadding(packet)
if NETWORK_A in network:
packet[Ether].src = get("MAC_PREFIX_TX") + ":20"
sendp(packet, iface = get("NETWORK_INTERFACE_A"),
verbose = False)
if NETWORK_B in network:
packet[Ether].src = get("MAC_PREFIX_TX") + ":40"
sendp(packet, iface = get("NETWORK_INTERFACE_B"),
verbose = False)
time.sleep( 0.6 )
def sequence5(self):
self.captureForSequence(5)
self.sendRSET()
for port in self.input_ports:
if port.port_characteristic != PORT_SAP:
continue
message = buildShortMessage(port, "PortId = %s" % \
port.RX_AFDX_port_id)
setattr(port, "ip_dst", get("TE_IP"))
setattr(port, "udp_dst", int(get("TE_UDP")))
esap = ESAP(port)
self.send(esap.buildCommand(message = message))
pollForResponse('ESAP')
def sequence3(self):
self.captureForSequence(3)
msg_small = buildStaticMessage(63, "small message")
for port in self.icmp_ports:
setattr(port, 'ip_src', get("NMF_IP"))
self.logger.info("Sending an ICMP from NMF ip : %s with "\
"small message" % get("NMF_IP"))
self.sendICMP(port, msg_small, False)
msg_big = buildStaticMessage(65, "big message")
for port in self.icmp_ports:
setattr(port, 'ip_src', get("NMF_IP"))
self.logger.info("Sending an ICMP from NMF ip : %s with "\
"big message" % get("NMF_IP"))
self.sendICMP(port, msg_big, False)
def run(self):
dummy_port = None
if len(self.snmp_ports) == 0:
self.logger.error("The ICD has no ports satisfying the sequence" \
" criteria. Hence sending from a dummy SNMP port")
dummy_port = (Factory.GET_SNMP_DummyPort(),)
self.snmp_ports = dummy_port
self.sendRSET()
for rxPort in self.snmp_ports:
oid_1 = getMIBOID('afdxEquipmentStatus')
oids_4kb = getMIBOIDBySize(220)
oids_8kb = getMIBOIDBySize(452)
self.logger.info("Sending an SNMP get request")
self.sendSNMP(rxPort, [oid_1])
self.logger.info("Sending an SNMP get request of " \
"size ~4Ko")
self.sendSNMP(rxPort, oids_4kb)
self.logger.info("Sending an SNMP get request of " \
"size ~8Ko")
self.sendSNMP(rxPort, oids_8kb)
if dummy_port:
Factory.REM_Port(dummy_port[0])
if get('SNMP_TRAPS_ENABLED').lower() == 'true':
self.logger.info("Listening for traps. Duration : 10 seconds")
time.sleep(10)
def __init__(self, application):
self.application = application
self.network = application.network
super(Script024, self).__init__("ITR-ES-024")
self.snmp_ports = self.getPorts({'port_characteristic' : PORT_SAP,
'udp_dst' : int(get('SNMP_UDP_PORT'))},
ICD_INPUT_VL)
def __addIpDetails(self):
port = self.__port
ip_layer = IP()
ip_layer.src = port.ip_src if hasattr(port, 'ip_src') else \
get("TE_IP")
if hasattr(port, 'dest_ip'):
port.ip_dst = port.dest_ip
elif port.ip_dst in ('', None):
port.ip_dst = get("TR_IP")
ip_layer.dst = port.ip_dst
ip_layer.id = self._sn_handler.nextIpId()
ip_layer.ttl = 1
#ip_layer.prot = 0x17
self.__packet = self.__packet/ip_layer
def __init__(self, application):
self.application = application
self.network = NETWORK_A
super(Script017, self).__init__("ITR-ES-017", has_sequences=True)
self.icmp_ports = self.getPorts({}, ICD_ICMP)
self.snmp_ports = self.getPorts({"udp_dst": int(get("SNMP_UDP_PORT"))}, ICD_INPUT_VL)
map(lambda port: setattr(port, "buffer_size", port.rx_vl_buff_size), self.icmp_ports)
def WRITE_ICMP(vlId, message):
port = __get_port(vlId, ICD_ICMP)
setattr(port, 'payload', message)
setattr(port, 'ip_dst', get('TR_IP'))
setattr(port, 'vl_id', int(port.rx_vl_id))
setattr(port, 'proto', 'ICMP')
__set_port(port, vlId, ICD_ICMP)
return port
def __fillRxPorts(self, ports):
for port in ports:
if port.udp_dst == int(get("TE_UDP")):
continue
message = "Port Id = %s" % port.RX_AFDX_port_id
self.logger.info("Filling the Rx port %s" % port.RX_AFDX_port_id)
self.send(message, port)
def __addUDPDetails(self):
port = self.__port
udp_layer = UDP()
udp_layer.sport = port.udp_src if hasattr(port, 'udp_src') else \
int(get("TE_UDP"))
udp_layer.dport = port.udp_dst
udp_layer.chksum = 0x00
#udp_layer.len = len(port.payload)
self.__packet = self.__packet/udp_layer
def __init__(self, application):
self.application = application
self.network = NETWORK_A
super(Script019, self).__init__("ITR-ES-019", has_sequences=True)
self.output_ports = self.getPorts({}, ICD_OUTPUT_VL)
self.input_ports = self.getPorts({"port_characteristic": PORT_QUEUING}, ICD_INPUT_VL)
self.snmp_ports = self.getPorts({"udp_dst": int(get("SNMP_UDP_PORT"))}, ICD_INPUT_VL)
self.output_ports = self.remove_common_ports(self.output_ports)
self.input_ports = self.remove_common_ports(self.input_ports)
def transmit(self, port, network):
self.__port = port
self.__createPacket()
time.sleep(0.5)
# to be removed, only for testing redundancy management
network = 'A'
for packet in self.__packet:
packet = self.__addPadding(packet)
if NETWORK_A in network:
packet[Ether].src = get("MAC_PREFIX_TX") + ":20"
sendp(packet, iface = get("NETWORK_INTERFACE_A"),
verbose = False)
if NETWORK_B in network:
packet[Ether].src = get("MAC_PREFIX_TX") + ":40"
sendp(packet, iface = get("NETWORK_INTERFACE_B"),
verbose = False)
def __init__(self, application):
self.application = application
self.network = NETWORK_A
super(Script023, self).__init__("ITR-ES-023", has_sequences = True)
self.sap_ports = self.getPorts({'port_characteristic' : PORT_SAP,
'udp_dst' : int(get('SNMP_UDP_PORT')),
'network_id' : NETWORK_A},
ICD_INPUT_VL)
self.input_ports = self.getPorts({}, ICD_INPUT_VL)
self.input_ports = self.remove_common_ports(self.input_ports)
def __init__(self, network):
self._integrity_check_result = False
self._redundancy_check_result = False
self.__network = network
self.__hooks = eval(get("HOOKS"))
if self.__hooks == None or type(self.__hooks) != dict:
self.__hooks = dict()
else:
for key in self.__hooks.keys():
target = self.__hooks[key]
self.__hooks[key] = target
def transmit_low(packet, network):
packet = self.__addPadding(packet)
packets = []
try:
if NETWORK_A in network:
packet[Ether].src = get("MAC_PREFIX_TX") + ":20"
if send:
sendp(packet, iface = get("NETWORK_INTERFACE_A"),
verbose = False)
else:
packets.append(packet)
if NETWORK_B in network:
packet[Ether].src = get("MAC_PREFIX_TX") + ":40"
if send:
sendp(packet, iface = get("NETWORK_INTERFACE_B"),
verbose = False)
else:
packets.append(packet)
except Exception, ex:
general_logger.exception(str(ex))
def run(self):
try:
filter_text = get("RECEIVER_NETWORK_FILTER_" + self.__network)
while True:
sniff(iface = self.__iface, prn = self.callback,
filter = filter_text,
store = 0, timeout = 10)
if self.__stop:
break
except ThreadExit: pass
except Exception, ex:
print 'Failed', str(ex)
def run(self):
try:
filter_text = get("RECEIVER_NETWORK_FILTER_" + self.__network)
while True:
#sniff(iface = self.__iface, prn = self.callback,
# filter = filter_text, timeout = 10,
# store = 0)
if self.__stop:
raise ThreadExit()
except ThreadExit:
general_logger.info("Thread on network " + self.__network +
" stopped")
except Exception, ex:
general_logger.error("Exception occured at receiver for network " +\
self.__network + " : " + str(ex))
general_logger.info("The application will not listen for packets" +\
" coming on network : " + self.__network)
traceback.print_exc(file=sys.stdout)
general_logger.error("Crash", exc_info = 1)
from com.afdxsuite.application.properties import get
from com.afdxsuite.core.network.scapy import load_mib, conf
oid_value_mapping = {}
load_mib(get("AFDXES_MIB"))
for oidname in conf.mib.keys():
val = conf.mib[oidname]
val = str(val).replace("enterprises", "1.3.6.1.4.1")
oid_value_mapping[val] = 0
print 'Loaded AFDX end system MIB objects'
SNMP_IP_MIB_CODE = "afdxProtocolInError"
SNMP_FRAG_MIB_CODE = "iPreassemblyInError"
SNMP_UDP_MIB_CODE = "afdxUDPCoherencyError"
def GET_SNMP_DummyPort():
dummy_data = "AFDX_INPUT_VL;port1;100;10;;A;BP;35854;VL_TestSCI_NMF_ADIS_SwitchN;A&B;128;8192;Active;yes;65500;26038;SNMP;SAP;SAP;yes;%s;161;8192;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;" % (get('TR_IP'))
port = ICD_AFDX_INPUT_VL(dummy_data.split(';'))
CONFIG_ENTRIES[ICD_INPUT_VL].append(port)
return port
from com.afdxsuite.config.parsers.icdparser import parseICD
from com.afdxsuite.application.properties import get
from com.afdxsuite.logging import afdxLogger
from com.afdxsuite.config.parsers import ICD_INPUT_VL
afdxLogger.info("Loading the ICD file")
parseICD(get("ICD_FILE"))
def __init__(self, network):
self.__network = network
self.__iface = get("NETWORK_INTERFACE_" + network)
self.listeners = Listeners()
super(ReceiverThread, self).__init__()
from com.afdxsuite.config.parsers.icdparser import parseICD
from com.afdxsuite.application.properties import get
from com.afdxsuite.logger import general_logger
from com.afdxsuite.config.parsers import ICD_INPUT_VL
from com.afdxsuite.core.network.scapy import load_mib
from com.afdxsuite.application import PARENT_PATH
general_logger.info("Loading the ICD file")
parseICD(get("ICD_FILE"))
load_mib(PARENT_PATH + "conf/" + get("ES_MIB"))
print "loaded mib file", PARENT_PATH + "conf/" + get("ES_MIB")
def __init__(self, application):
self.application = application
self.network = NETWORK_A
super(Script018, self).__init__("ITR-ES-018")
self.snmp_ports = self.getPorts({'udp_dst' : int(get("SNMP_UDP_PORT"))},
ICD_INPUT_VL)
