178 lines
5.5 KiB
Python
Executable file
178 lines
5.5 KiB
Python
Executable file
#!/usr/bin/env python
|
|
|
|
#
|
|
# Copyright (c) 2017 Stephen Ibanez
|
|
# All rights reserved.
|
|
#
|
|
# This software was developed by Stanford University and the University of Cambridge Computer Laboratory
|
|
# under National Science Foundation under Grant No. CNS-0855268,
|
|
# the University of Cambridge Computer Laboratory under EPSRC INTERNET Project EP/H040536/1 and
|
|
# by the University of Cambridge Computer Laboratory under DARPA/AFRL contract FA8750-11-C-0249 ("MRC2"),
|
|
# as part of the DARPA MRC research programme.
|
|
#
|
|
# @NETFPGA_LICENSE_HEADER_START@
|
|
#
|
|
# Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
|
|
# license agreements. See the NOTICE file distributed with this work for
|
|
# additional information regarding copyright ownership. NetFPGA licenses this
|
|
# file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
|
|
# "License"); you may not use this file except in compliance with the
|
|
# License. You may obtain a copy of the License at:
|
|
#
|
|
# http://www.netfpga-cic.org
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, Work distributed
|
|
# under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
|
|
# CONDITIONS OF ANY KIND, either express or implied. See the License for the
|
|
# specific language governing permissions and limitations under the License.
|
|
#
|
|
# @NETFPGA_LICENSE_HEADER_END@
|
|
#
|
|
|
|
|
|
"""
|
|
Used to create the Tuple_in.txt and Tuple_out.txt files for the
|
|
SDNet simulations
|
|
"""
|
|
|
|
import argparse, collections, sys
|
|
|
|
# this defines the common sume_metadata
|
|
from sss_sume_metadata import *
|
|
|
|
tuple_in_file = "Tuple_in.txt"
|
|
tuple_expect_file = "Tuple_expect.txt"
|
|
|
|
# Diget Data MUST be 256 bits
|
|
""" Digest Data:
|
|
unused (256 bits)
|
|
"""
|
|
|
|
dig_field_len = collections.OrderedDict()
|
|
dig_field_len['unused'] = 256
|
|
|
|
#initialize tuple_expect
|
|
dig_tuple_expect = collections.OrderedDict()
|
|
dig_tuple_expect['unused'] = 0
|
|
|
|
"""
|
|
Clear the tuple files
|
|
"""
|
|
def clear_tuple_files():
|
|
with open(tuple_in_file, "w") as f:
|
|
f.write("")
|
|
|
|
with open(tuple_expect_file, "w") as f:
|
|
f.write("")
|
|
|
|
|
|
"""
|
|
Return a binary string with length = field_len_dic[field_name]
|
|
"""
|
|
def get_bin_val(field_name, value, field_len_dic):
|
|
format_string = "{0:0%db}" % field_len_dic[field_name]
|
|
bin_string = format_string.format(value)
|
|
return bin_string
|
|
|
|
"""
|
|
Given a binary string, return the hex version
|
|
"""
|
|
def bin_to_hex(bin_string):
|
|
hex_string = ''
|
|
assert(len(bin_string) % 4 == 0)
|
|
for i in range(0,len(bin_string),4):
|
|
hex_string += "{0:1x}".format(int(bin_string[i:i+4], 2))
|
|
return hex_string
|
|
|
|
"""
|
|
Write the next line of the Tuple_in.txt and Tuple_expect.txt
|
|
"""
|
|
def write_tuples():
|
|
with open("Tuple_in.txt", "a") as f:
|
|
tup_bin_string = ''
|
|
for field_name, value in sume_tuple_in.iteritems():
|
|
bin_val = get_bin_val(field_name, value, sume_field_len)
|
|
tup_bin_string += bin_val
|
|
f.write(bin_to_hex(tup_bin_string) + '\n')
|
|
|
|
with open("Tuple_expect.txt", "a") as f:
|
|
tup_bin_string = ''
|
|
for field_name, value in dig_tuple_expect.iteritems():
|
|
bin_val = get_bin_val(field_name, value, dig_field_len)
|
|
tup_bin_string += bin_val
|
|
f.write(bin_to_hex(tup_bin_string) + ' ')
|
|
|
|
tup_bin_string = ''
|
|
for field_name, value in sume_tuple_expect.iteritems():
|
|
bin_val = get_bin_val(field_name, value, sume_field_len)
|
|
tup_bin_string += bin_val
|
|
f.write(bin_to_hex(tup_bin_string) + '\n')
|
|
|
|
|
|
###############################
|
|
## Functions to parse tuples ##
|
|
###############################
|
|
|
|
def find_tup_len(field_len_dic):
|
|
num_bits = 0
|
|
for length in field_len_dic.values():
|
|
num_bits += length
|
|
return num_bits
|
|
|
|
"""
|
|
Given a hex string, convert it to a binary string
|
|
"""
|
|
def hex_to_bin(hex_string, length):
|
|
fmat_string = '{0:0%db}' % length
|
|
bin_string = fmat_string.format(int(hex_string, 16))
|
|
return bin_string
|
|
|
|
def check_length(bin_string, field_len_dic):
|
|
num_bits = find_tup_len(field_len_dic)
|
|
try:
|
|
assert(len(bin_string) == num_bits)
|
|
except:
|
|
print 'ERROR: unexpected input'
|
|
print 'len(bin_string) = ', len(bin_string)
|
|
print 'num_bits = ', num_bits
|
|
sys.exit(1)
|
|
|
|
"""
|
|
Given hex string representation of a tuple, return the parsed version of it
|
|
"""
|
|
def parse_tup_string(tup_string, field_len_dic):
|
|
tup_len = find_tup_len(field_len_dic)
|
|
bin_string = hex_to_bin(tup_string, tup_len)
|
|
check_length(bin_string, field_len_dic)
|
|
tup = collections.OrderedDict()
|
|
i = 0
|
|
for (field,length) in field_len_dic.iteritems():
|
|
tup[field] = int(bin_string[i:i+length], 2)
|
|
i += length
|
|
return tup
|
|
|
|
def parse_line(line, tuple_type):
|
|
if tuple_type == 'sume':
|
|
field_len = sume_field_len
|
|
elif tuple_type == 'digest':
|
|
field_len = dig_field_len
|
|
else:
|
|
print >> sys.stderr, "ERROR: unsupported tuple_type, must one of: [sume, digest]"
|
|
sys.exit(1)
|
|
tup_string = line.strip()
|
|
tup = parse_tup_string(tup_string, field_len)
|
|
print "Parsed Tuple:\n", '-----------------------'
|
|
for (key, val) in tup.items():
|
|
if (key in ['src_port', 'dst_port']):
|
|
print key, " = {0:08b}".format(val)
|
|
else:
|
|
print key, " = ", val
|
|
|
|
if __name__ == "__main__":
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument('--parse', type=str, help="A tuple line to parse")
|
|
parser.add_argument('tuple_type', type=str, help="Which tuple type to parse: sume, digest")
|
|
args = parser.parse_args()
|
|
|
|
parse_line(args.parse, args.tuple_type)
|
|
|