def _update_v6_fields(self, source_obj, dest_obj):
if not source_obj._next_header._is_default:
dest_obj.is_override_next_header = True
dest_obj.next_header = Converter.convertstring2int(
source_obj._next_header.current_val)
dest_obj.traffic_class = int(
source_obj.traffic_class
) #int(Converter.remove_non_hexa_sumbols(hex(int(source_obj.traffic_class))))#Converter.convertstring2int(source_obj.traffic_class)
dest_obj.hop_limit = int(
source_obj.hop_limit) #Converter.convertstring2int
dest_obj.flow_label = Converter.convertstring2int(
source_obj.flow_label)
dest_obj.src_addr_hi, dest_obj.src_addr_lo = self._handle_v6(
source_obj.source_ip.value)
dest_obj.dst_addr_hi, dest_obj.dst_addr_lo = self._handle_v6(
source_obj.destination_ip.value)
dest_obj.src_addr_mode = OstinatoEnums.unified_to_ostinato(
source_obj.source_ip.mode)
dest_obj.src_addr_count = int(
source_obj.source_ip.count
) if source_obj.source_ip.count != '0' else 1
dest_obj.dst_addr_mode = OstinatoEnums.unified_to_ostinato(
source_obj.destination_ip.mode)
dest_obj.dst_addr_count = int(
source_obj.destination_ip.count
) if source_obj.destination_ip.count != '0' else 1
return dest_obj
def create_tcp_obj(cls, utg_tcp):
flags_list = [
int(utg_tcp.flag_urgent_pointer_valid),
int(utg_tcp.flag_acknowledge_valid),
int(utg_tcp.flag_push_function),
int(utg_tcp.flag_reset_connection),
int(utg_tcp.flag_synchronize_sequence),
int(utg_tcp.flag_no_more_data_from_sender)
]
flags = functools.reduce(lambda out, x: (out << 1) + int(x),
flags_list, 0)
header_obj = TCP(
sport=int(utg_tcp.source_port.value),
dport=int(utg_tcp.destination_port.value),
seq=Converter.hexaString2int(utg_tcp.sequence_number),
ack=Converter.hexaString2int(utg_tcp.acknowledgement_number),
#off_x2 TODO
flags=flags,
win=Converter.hexaString2int(utg_tcp.window),
#sum TODO
urp=Converter.hexaString2int(utg_tcp.urgent_pointer)
#opts TODO
)
return header_obj
def _handle_v6(self, input):
input = Converter.expand_ipv6(input)
input = Converter.remove_non_hexa_sumbols(input)
split = int(len(input) / 2)
low = Converter.convertstring2int(input[split:])
high = Converter.convertstring2int(input[:split])
return high, low
def _apply_data_pattern(self):
sp_obj = self._stream_driver_obj.frame #type: StcStream()
if self.packet.data_pattern.type is TGEnums.DATA_PATTERN_TYPE.FIXED:
#!!! currently custom type not supported by 400G ,used custom header instead
pl = Converter.remove_non_hexa_sumbols(
self.packet.data_pattern.value)
sp_obj.add_header(StcFrame_Layers.UpperLayerProtocols_II.Custom,
pattern=pl)
#sp_obj.Payload.update_fields(pattern=self.packet.data_pattern.value)
# pl = self.packet.data_pattern.value
# res = ''
# lst = pl.split()
# for x in lst:
# r = Converter.convertstring2int(x)
# res += str(r)
# res += ' '
# self._stream_driver_obj.frame.custom_pl(res)
return
elif self.packet.data_pattern.type is TGEnums.DATA_PATTERN_TYPE.INCREMENT_BYTE \
or self.packet.data_pattern.type is TGEnums.DATA_PATTERN_TYPE.INCREMENT_WORD:
fill_type = 'INCR'
data = 0
elif self.packet.data_pattern.type is TGEnums.DATA_PATTERN_TYPE.DECREMENT_BYTE\
or self.packet.data_pattern.type is TGEnums.DATA_PATTERN_TYPE.DECREMENT_WORD:
fill_type = 'DECR'
data = 0
elif self.packet.data_pattern.type is TGEnums.DATA_PATTERN_TYPE.REPEATING:
fill_type = 'CONSTANT'
int_pl = Converter.convertstring2int(
self.packet.data_pattern.value)
data = int_pl
self._stream_driver_obj.set_attributes(FillType=fill_type,
ConstantFillPattern=data)
def handle_filter_conditions(utg_trigger, ost_trigger):
for cond in utg_trigger.conditions:
term = ost_trigger.terms.add()
term.offset = cond.match_term.offset
pattern = Converter.remove_non_hexa_sumbols(
cond.match_term.pattern)
mask = Converter.remove_non_hexa_sumbols(
cond.match_term.mask
) if cond.match_term.mask is not None else "F" * len(pattern)
term.pattern = pattern
term.mask = mask
term.is_not = True if cond.logical_operator is TGEnums.LOGICAL_OPERATOR.NOT else False
def refresh(self):
self._parent._driver_obj.wait_for_up(20)
self._parent._driver_obj.interfaceTable.send_arp_refresh()
res_table = self._parent._driver_obj.interfaceTable.read_port_neighbors(
)
self.learned_table = []
for if_key in res_table:
iface_table = res_table[if_key]
for entry in iface_table:
isIp4 = True if Converter.intIp2string(Converter.uc23(
entry[1])) else False
if isIp4:
self.learned_table.append(learned_entry(
entry[0], entry[1]))
def create_gre_obj(cls, utg_gre):
# type: (Packet.GRE) -> object
obj = GRE()
#bin_headers = '0x' + binascii.hexlify(obj.bin()).decode('utf-8')
obj.version_number = utg_gre.version
#bin_headers = '0x' + binascii.hexlify(obj.bin()).decode('utf-8')
if utg_gre.use_checksum is True:
obj.opts.append(GREOptionChecksum(checksum=0))
obj.opts.append(GREOptionReserve_1())
obj.checksum_bit = 1
#bin_headers = '0x' + binascii.hexlify(obj.bin()).decode('utf-8')
if utg_gre.key_field is not None:
obj.opts.append(
GREOptionKey(
key=Converter.convertstring2int(utg_gre.key_field)))
obj.key_bit = 1
#bin_headers = '0x' + binascii.hexlify(obj.bin()).decode('utf-8')
if utg_gre.sequence_number is not None:
obj.opts.append(
GREOptionSequence(sequence=Converter.convertstring2int(
utg_gre.sequence_number)))
obj.sequence_bit = 1
#bin_headers = '0x' + binascii.hexlify(obj.bin()).decode('utf-8')
if utg_gre.use_checksum is True:
innerPacketData = obj.bin()
if utg_gre.l3_proto is TGEnums.L3_PROTO.IPV4:
obj.protocol_type = ETH_TYPE_IP
packer_v4 = utg_gre.ipv4.to_packer()
innerPacketData += packer_v4.bin()
elif utg_gre.l3_proto is TGEnums.L3_PROTO.IPV6:
obj.protocol_type = ETH_TYPE_IP6
v6 = utg_gre.ipv6.to_packer()
innerPacketData += v6.bin()
else:
proto = Converter.remove_non_hexa_sumbols(utg_gre.l3_proto)
proto = Converter.hexaString2int(proto)
obj.protocol_type = proto
if utg_gre.l4_proto is TGEnums.L4_PROTO.UDP:
packer_udp = utg_gre.udp.to_packer()
innerPacketData += packer_udp.bin()
elif utg_gre.l4_proto is TGEnums.L4_PROTO.TCP:
packer_tcp = utg_gre.tcp.to_packer()
innerPacketData += packer_tcp.bin()
s = checksum.in_cksum(innerPacketData)
obj.opts[0].checksum = s
#bin_headers = '0x' + binascii.hexlify(obj.bin()).decode('utf-8')
return obj
def pattern_to_ascii_chars(pattern):
asci_chars = bytes() if PY3K else ""
patternString = Converter.remove_non_hexa_sumbols(pattern[:])
while patternString:
tmp_char = chr(int(patternString[:2], 16))
char = bytes(tmp_char, 'latin-1') if PY3K else tmp_char
asci_chars += char
patternString = patternString[2:]
return bytes(asci_chars) if PY3K else asci_chars
def _update_v4_fields(self, source_obj, dest_obj):
dest_obj.dst_ip = Converter.stringIp2int(
source_obj.destination_ip.value)
dest_obj.dst_ip_mode = OstinatoEnums.unified_to_ostinato(
source_obj.destination_ip.mode)
dest_obj.dst_ip_count = int(source_obj.destination_ip.count)
dest_obj.dst_ip_mask = Converter.stringIp2int(
source_obj.destination_ip.mask)
dest_obj.src_ip = Converter.stringIp2int(source_obj.source_ip.value)
dest_obj.src_ip_mode = OstinatoEnums.unified_to_ostinato(
source_obj.source_ip.mode)
dest_obj.src_ip_count = int(source_obj.source_ip.count)
dest_obj.src_ip_mask = Converter.stringIp2int(
source_obj.source_ip.mask)
dest_obj.ttl = int(source_obj.ttl)
dest_obj.is_override_hdrlen = source_obj.enable_header_len_override
dest_obj.is_override_totlen = source_obj.length_override
if source_obj.checksum_mode is TGEnums.CHECKSUM_MODE.OVERRIDE:
dest_obj.is_override_cksum = True
dest_obj.cksum = int(source_obj.custom_checksum, 16)
dest_obj.ver_hdrlen = source_obj.header_len_override_value
dest_obj.tos = int(source_obj.dscp_decimal_value, 16)
dest_obj.totlen = source_obj.length_value
dest_obj.id = int(source_obj.identifier)
dest_obj.frag_ofs = source_obj.fragment_offset_decimal_value
#ip.options = source_obj.options_padding ::==>>Ostinato's TODO ip options
#ip.is_override_ver =
if self.packet.l4_proto is TGEnums.L4_PROTO.GRE:
dest_obj.is_override_proto = True
dest_obj.proto = 0x2F
elif self.packet.l4_proto is TGEnums.L4_PROTO.NONE:
#common default value
dest_obj.is_override_proto = True
dest_obj.proto = source_obj.protocol
elif not source_obj._protocol._is_default:
dest_obj.is_override_proto = True
dest_obj.proto = source_obj.protocol
df = 0 if source_obj.fragment_enable else 2
mf = 0 if source_obj.fragment_last_enable else 1
dest_obj.flags = df + mf
return dest_obj
def __init__(self, initdata=None):
if initdata:
data = initdata.split("/")
else:
data = [None, None, None]
if data[0]:
self.chassis = data[0]
if data[1]:
self.slot = data[1]
isIp = Converter.stringIp2int(data[2])
self.port = data[2] if isIp is None else str(isIp)
def getPortDataConfig(cls,pid):
try:
isIp = False if pid < 256 else Converter.intIp2string(pid)
searchName = 'slan0'+str(pid) if not isIp else cls._portNameByIP(isIp)
ostPortInfo = list(filter(lambda ostPrt: searchName in ostPrt.name.lower() ,cls._PortConfigList.port[:]))[0]
pIdList = ost_pb.PortIdList()
pIdList.port_id.add().id = ostPortInfo.port_id.id
pConfig = cls._drone.getPortConfig(pIdList)
except Exception as e:
raise Exception("Failed to assotiate ip to Nic... maybe wrong ip?\n" + "\n" + str(e))
return pIdList,pConfig
def apply_filters(self):
self._logger.info(self._get_port_log_title(), self._get_port_log_message())
terms = list(set().union(self.filter_properties.filters[1]._get_match_term_list(),
self.filter_properties.filters[2]._get_match_term_list(),
self.filter_properties.filters[3]._get_match_term_list(),
self.filter_properties.capture_filter._get_match_term_list()
)
)
self._clear_filters()
for i, term in enumerate(terms):
if term._type is not TGEnums.MATCH_TERM_TYPE.SIZE:
mask = 'FFFFFFFFFFFF0000' if term.mask is None else term.mask
mask = "{:0<18}".format('0x' + Converter.remove_non_hexa_sumbols(mask.upper()))
copyPattern = "{:0<18}".format('0x'+Converter.remove_non_hexa_sumbols(term._pattern[:]).upper())
self._update_field(driver_field='PM_CREATE',value=xenaCommandParams.build(ix=i))
self._update_field(driver_field='PM_POSITION', value=xenaCommandParams.build([term.offset],ix=i))
self._update_field(driver_field='PM_MATCH', value=xenaCommandParams.build([mask,copyPattern],ix=i))
term._id = pow(2, i)
else:
self._update_field(driver_field='PL_CREATE', value=xenaCommandParams.build(ix=1))
self._update_field(driver_field='PL_LENGTH', value=xenaCommandParams.build(['AT_LEAST', term.from_size], ix=1))
self._update_field(driver_field='PL_CREATE', value=xenaCommandParams.build(ix=2))
self._update_field(driver_field='PL_LENGTH', value=xenaCommandParams.build(['AT_MOST', term.to_size], ix=2))
term._id = pow(2, 17) +pow(2, 18)
triggers = list(filter(lambda x: x is not None, self.filter_properties.filters))
#TODO delete filters/conditions on reserve
for trId,trigger in enumerate(triggers):
if trigger.enabled:
cond_lst = trigger.conditions # type: list[condition]
conditions_matrix = [0, 0, 0, 0, 0, 0]
pair_index = 0
for cn in cond_lst:
in_pair_index = 1 if cn.logical_operator is TGEnums.LOGICAL_OPERATOR.NOT else 0
if cn.logical_operator is TGEnums.LOGICAL_OPERATOR.OR:
pair_index += 2
conditions_matrix[pair_index+in_pair_index] += cn.match_term._id
if any(conditions_matrix):
self._port_driver_obj.add_filter(xenaCommandParams.build(conditions_matrix))
def _apply_udfs(self):
for udf in self.packet.modifiers:
curUdf = self.packet.modifiers[udf]
if curUdf.enabled is True:
p, pOffset = self._get_header_by_offset(curUdf.byte_offset)
if p:
protoproto = self._protoprotoMap[id(p)]
variable_field = protoproto.variable_field.add()
variable_field.offset = curUdf.byte_offset - pOffset
variable_field.type = int(curUdf.bit_type.value / 16)
variable_field.value = Converter.stringMac2int(
curUdf.repeat_init, ' ')
variable_field.mode = OstinatoEnums.unified_to_ostinato(
curUdf.repeat_mode)
variable_field.count = int(curUdf.repeat_count)
variable_field.step = int(curUdf.repeat_step)
def _add_update_modifier(self,
field,
offset,
count=None,
mode=TGEnums.MODIFIER_UDF_REPEAT_MODE.UP,
initVal='0',
step=1):
from xenavalkyrie.xena_stream import XenaModifierAction
sMask = '0xFFFF0000'
rep = 1
smMaxVal = 0xFFFF
startValue = Converter.convertstring2int(initVal)
startValue &= 0xFFFF
adapter = 1 #if step > 1 else 1
if mode is TGEnums.MODIFIER_UDF_REPEAT_MODE.UP:
mode = XenaModifierAction.increment
minVal = startValue
maxVal = smMaxVal - 1 if count is None else startValue + step * (
count - adapter)
else:
mode = XenaModifierAction.decrement
maxVal = startValue
minVal = 0 if count is None else startValue - count * step + adapter
if not field._driver_obj:
field._driver_obj = self._stream_driver_obj.add_modifier(
position=offset,
mask=sMask,
action=mode,
repeat=rep,
min_val=minVal,
step=step,
max_val=maxVal)
else:
field._driver_obj.update(position=offset,
mask=sMask,
action=mode,
repeat=rep,
min_val=minVal,
step=step,
max_val=maxVal)
def v6_to_packer_format(v6_addr):
return pattern_to_ascii_chars(
Converter.remove_non_hexa_sumbols(Converter.expand_ipv6(v6_addr)))
def apply_filters(self):
def handle_filter_conditions(trigger, current_stat_prefix):
# type: (trafficFilter, object) -> object
patternCount = 0
udpate_list = {}
for cond in trigger.conditions:
if cond.match_term._type is TGEnums.MATCH_TERM_TYPE.MAC_DA:
dest_field = 'CaptureFilterDA'
value = 'notAddr' if cond.logical_operator is TGEnums.LOGICAL_OPERATOR.NOT else 'addr'
elif cond.match_term._type is TGEnums.MATCH_TERM_TYPE.MAC_SA:
dest_field = 'CaptureFilterSA'
value = 'notAddr' if cond.logical_operator is TGEnums.LOGICAL_OPERATOR.NOT else 'addr'
elif cond.match_term._type is TGEnums.MATCH_TERM_TYPE.CUSTOM:
dest_field = 'CaptureFilterPattern'
if patternCount > 0:
value = "pattern1AndPattern2"
else:
value = 'notPattern' if cond.logical_operator is TGEnums.LOGICAL_OPERATOR.NOT else 'pattern'
patternCount += 1
elif cond.match_term._type is TGEnums.MATCH_TERM_TYPE.SIZE:
from_size = 'CaptureFilterFrameSizeFrom'
to_size = 'CaptureFilterFrameSizeTo'
size_enable = 'CaptureFilterFrameSizeEnable'
udpate_list[size_enable] = True
udpate_list[from_size] = cond.match_term._from_size
udpate_list[to_size] = cond.match_term._to_size
continue
if patternCount < 2 or cond.match_term._type is not TGEnums.MATCH_TERM_TYPE.CUSTOM:
value += str(cond.match_term._id)
udpate_list[dest_field] = value
filter_obj.update(**udpate_list)
#field = 'filter.' + current_stat_prefix + dest_field
#self._update_field(driver_field=field, value=value)
# caller_name = inspect.stack()[1][3]
# need_write = False if caller_name is "apply" else True
terms = list(set().union(
self.filter_properties.filters[1]._get_match_term_list(),
self.filter_properties.filters[2]._get_match_term_list(),
self.filter_properties.filters[3]._get_match_term_list(),
self.filter_properties.capture_filter._get_match_term_list()))
udpate_list = {}
ixiaResourceMap = {'SA': 0, 'DA': 0, 'Pattern': 0}
for term in terms:
patternValue = term._pattern if term._type is not TGEnums.MATCH_TERM_TYPE.SIZE else None
patternValue = patternValue.replace('{', '').replace('}', '')
if term._type is TGEnums.MATCH_TERM_TYPE.MAC_DA:
dest_field = 'DA'
elif term._type is TGEnums.MATCH_TERM_TYPE.MAC_SA:
dest_field = 'SA'
elif term._type is TGEnums.MATCH_TERM_TYPE.CUSTOM:
dest_field = 'Pattern'
patId = ixiaResourceMap[dest_field] + 1
udpate_list['PatternOffset' + str(patId)] = term._offset
#self._update_field(driver_field='filterPallette.patternOffset' + str(patId), value=term._offset)
spacedPattern = ""
copyPattern = Converter.remove_non_hexa_sumbols(
term._pattern[:])
while copyPattern:
spacedPattern += copyPattern[:2]
spacedPattern += " "
copyPattern = copyPattern[2:]
patternValue = spacedPattern
elif term._type is TGEnums.MATCH_TERM_TYPE.SIZE:
continue
ixiaResourceMap[dest_field] += 1
term._id = ixiaResourceMap[dest_field]
field = dest_field + str(ixiaResourceMap[dest_field])
udpate_list[field] = patternValue
mask = dest_field + 'Mask' + str(ixiaResourceMap[dest_field])
if term._mask is not None:
mask_val = term._mask
else:
pat = Converter.remove_non_hexa_sumbols(patternValue)
mask_len = len(pat) / 2 - 1
mask_val = "00"
for i in range(int(mask_len)):
mask_val += " 00"
udpate_list[mask] = mask_val
# fp_obj.Pattern1 = 'AA'
# fp_obj.DA1 = '00 11 22 33 44 55'
if udpate_list:
#cap_obj = self._port_driver_obj.Capture # type: Capture
fp_obj = self._port_driver_obj.Capture.FilterPallette # type: FilterPallette
fp_obj.update(**udpate_list)
triggers = list(
filter(lambda x: x is not None, self.filter_properties.filters))
triggers.append(self.filter_properties.capture_filter)
#self._port_driver_obj.filter.ix_set_default()
for trId, trigger in enumerate(triggers):
trId += 1
if trId < 3:
continue
current_stat_prefix = 'userDefinedStat' + str(trId)
elif trId == 4:
current_stat_prefix = 'captureFilter'
filter_obj = self._port_driver_obj.Capture.Filter # type: Filter
filter_obj.CaptureFilterEnable = int(trigger.enabled)
elif trId == 3:
continue
current_stat_prefix = 'captureTrigger'
#filter_obj.CaptureFilterEnable = int(trigger.enabled)
if not trigger.enabled:
continue
handle_filter_conditions(trigger, current_stat_prefix)
def init_vlan(utg_vlan, ost_vlan):
ost_vlan.is_override_tpid = True
ost_vlan.tpid = Converter.convertstring2int(utg_vlan.proto)
priority = (int(utg_vlan.priority) << 13)
cfi = (int(utg_vlan.cfi) << 12)
ost_vlan.vlan_tag = int(utg_vlan.vid.value) + priority + cfi
