You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

178 lines
5.5 KiB

#!/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)