def main():
# parse all the arguments to the client
parser = argparse.ArgumentParser(description='CS 352 Socker Echo Server ')
parser.add_argument('-l',
'--localport',
help='local sock352 UDP port',
required=True)
parser.add_argument('-x', '--debuglevel', help='Debug Level')
parser.add_argument('-z', '--dropprob', help='Drop Probability')
args = vars(parser.parse_args())
local_port = int(args['localport'])
# set the debug level. 0 = no debug statements, 10 = maximum debug output
if (args['debuglevel'] == None):
debug_level = 0
else:
debug_level = int(args['debuglevel'])
# set the drop probability. 0.0 = no data drops, 1.0 = drop everything
if (args['dropprob'] == None):
probability = 0.0
else:
probability = float(args['dropprob'])
serverSock = sock352.Socket()
serverSock.bind(('', local_port))
# set the debug level in the library
serverSock.set_random_seed(352)
serverSock.set_debug_level(debug_level)
serverSock.set_drop_prob(probability)
print "here"
from_addr = serverSock.accept()
print "2"
num_lines_str = serverSock.recvfrom(1000)
line_count = int(num_lines_str)
print("server -- will echo %d lines " % (line_count))
while (line_count > 0):
#Read from UDP socket into message, client address
message = serverSock.recvfrom(MAX_SIZE)
print("server -- got packet len %d line %s" % (len(message), message))
serverSock.sendto(message)
line_count = line_count - 1
print("server -- %d lines to go " % (line_count))
serverSock.close()
print "test1"
def main():
# parse all the arguments to the client
if (sys.argv[0]):
prog_name = sys.argv[0]
else:
prog_name = 'rel_bw_test.py'
parser = argparse.ArgumentParser(description='CS 352 Socket Client')
parser.add_argument('-f',
'--filename',
help='File to Echo',
required=False)
parser.add_argument('-d',
'--destination',
help='Destination IP Host',
required=True)
parser.add_argument('-p',
'--remoteport',
help='Remote sock352 UDP port',
required=False)
parser.add_argument('-l',
'--localport',
help='Local sock352 UDP port',
required=True)
parser.add_argument('-s',
'--server',
help='Run as server',
action='store_true')
parser.add_argument('-x', '--debuglevel', help='Debug Level')
parser.add_argument('-z', '--dropprob', help='Drop Probability')
# get the arguments into local variables
args = vars(parser.parse_args())
filename = args['filename']
destinationIP = args['destination']
remote_port = args['remoteport']
local_port = int(args['localport'])
run_as_server = args['server']
# set the debug level. 0 = no debug statements, 10 = maximum debug output
if (args['debuglevel'] == None):
debug_level = 0
else:
debug_level = int(args['debuglevel'])
# set the drop probability. 0.0 = no data drops, 1.0 = drop everything
if (args['dropprob'] == None):
probability = 0.0
else:
probability = float(args['dropprob'])
# open the file for reading
if (filename):
try:
filesize = os.path.getsize(filename)
fd = open(filename, "rb")
except:
print("error opening file: %s" % (filename))
exit(-1)
else:
pass
# create a socket and connect to the remote server
s = sock352.Socket()
dest_addr = (destinationIP, int(remote_port))
# use the MD5 hash algorithm to validate all the data is correct
mdhash_sent = md5.new()
mdhash_recv = md5.new()
# a lines of lines to echo back
# for each line, take a time-stamp, send and recive the line, update the list of RTT times,
# and then update the MD5 hash of the sent and received data
# the maximum packet size for this transfer is 4K
max_pkt_size = (4 * 1024)
# set the debug level in the library
s.set_random_seed(352)
s.set_debug_level(debug_level)
s.set_drop_prob(probability)
# start time stamp to compute the bandwidth
start_stamp = time.time()
# run as a client or server
if (run_as_server):
s.bind(('', local_port))
from_addr = s.accept()
else:
s.connect(dest_addr)
# the first message is the file size to send
bytes_to_send = filesize
send = s.sendto(str(bytes_to_send))
# how many bytes to receive from the remote side
recv_size = int(s.recvfrom(max_pkt_size))
# this is the downcounter
bytes_to_receive = recv_size
total_bytes = filesize + recv_size
print("%s: sending %d bytes, receiving %d bytes " %
(prog_name, bytes_to_send, bytes_to_receive))
# loop until there are no bytes left to send or receive
i = 0
while ((bytes_to_send > 0) or (bytes_to_receive > 0)):
if (bytes_to_send > 0):
if (bytes_to_send >= max_pkt_size):
size_to_send = max_pkt_size
else:
size_to_send = bytes_to_send
send_data = fd.read(size_to_send)
send = s.sendto(send_data)
bytes_to_send = bytes_to_send - size_to_send
mdhash_sent.update(send_data)
i = i + 1
if ((i % 100) == 0):
print ".",
if (bytes_to_receive > 0):
recv_data = s.recvfrom(max_pkt_size)
bytes_to_receive = bytes_to_receive - len(recv_data)
mdhash_recv.update(recv_data)
print " "
digest_sent = mdhash_sent.digest()
digest_recv = mdhash_recv.digest()
send = s.sendto(digest_recv)
remote_digest = s.recvfrom(max_pkt_size)
s.close()
end_stamp = time.time()
lapsed_seconds = float(end_stamp - start_stamp)
fd.close()
print "rel: sent digest: x%s received digest x%s remote digest x%s " % (
binascii.hexlify(digest_sent), binascii.hexlify(digest_recv),
binascii.hexlify(remote_digest))
# this part send the lenght of the digest, then the
# digest. It will be check on the server
# compute bandwidthstatisticis
total_time = end_stamp - start_stamp
bandwidth = (float(total_bytes) / total_time) / 1000000.0
# make sure the digest from the remote side matches what we sent
failed = False
for i, sent_byte in enumerate(digest_sent):
remote_byte = remote_digest[i]
if (sent_byte != remote_byte):
print("%s: digest failed at byte %d diff: %c %c " %
(prog_name, i, sent_byte, remote_byte))
failed = True
if (not failed):
print("%s: digest succeeded bandwidth %f Mbytes/sec" %
(prog_name, bandwidth))
# this makes sure all threads exit
os._exit(1)
def main():
# parse all the arguments to the client
parser = argparse.ArgumentParser(description='CS 352 Socket Client')
parser.add_argument('-f',
'--filename',
help='File to Echo',
required=False)
parser.add_argument('-d',
'--destination',
help='Destination IP Host',
required=True)
parser.add_argument('-p',
'--remoteport',
help='remote sock352 UDP port',
required=False)
parser.add_argument('-k',
'--keychain',
help='keychain file',
required=True)
parser.add_argument('-l',
'--localport',
help='local sock352 UDP port',
required=True)
parser.add_argument('-x', '--debuglevel', help='Debug Level')
parser.add_argument('-z', '--dropprob', help='Drop Probability')
# get the arguments into local variables
debug_level = 0
args = vars(parser.parse_args())
filename = args['filename']
destinationIP = args['destination']
remote_port = args['remoteport']
local_port = args['localport']
keychain_file = args['keychain']
# set the debug level. 0 = no debug statements, 10 = maximum debug output
if (args['debuglevel'] == None):
debug_level = 0
else:
debug_level = int(args['debuglevel'])
# set the drop probability. 0.0 = no data drops, 1.0 = drop everything
if (args['dropprob'] == None):
probability = 0.0
else:
probability = float(args['dropprob'])
# open the file for reading
if (filename):
try:
filesize = os.path.getsize(filename)
fd = open(filename, "rb")
except:
print("error opening file: %s" % (filename))
exit(-1)
else:
pass
# create a socket and connect to the remote server
s = sock352.Socket()
# read the keychain file
s.readKeyChain(keychain_file)
# set the debug level in the library
s.set_random_seed(352)
s.set_debug_level(debug_level)
s.set_drop_prob(probability)
dest_addr = (destinationIP, int(remote_port))
# use the MD5 hash algorithm to validate all the data is correct
mdhash_sent = md5.new()
mdhash_recv = md5.new()
# a lines of lines to echo back
lines = fd.readlines()
rtt_times = []
# for each line, take a time-stamp, send and recive the line, update the list of RTT times,
# and then update the MD5 hash of the sent and received data
zero_stamp = time.clock()
s.connect(dest_addr)
num_lines = str(len(lines))
s.sendto(num_lines)
line_number = int(num_lines)
for line in lines:
start_stamp = time.clock()
if (debug_level > 0):
print "rel_client -- sending line %d: %s" % (line_number, line)
send = s.sendto(line)
recv_data = s.recvfrom(len(line))
end_stamp = time.clock()
lapsed_seconds = float(end_stamp - start_stamp)
rtt_times.append(lapsed_seconds)
line_number = line_number - 1
# update the sent and received data
mdhash_sent.update(line)
mdhash_recv.update(recv_data)
# this allows use to time the entire loop, not just every RTT
# Allows estimation of the protocol delays
s.close()
final_stamp = end_stamp
# this part send the lenght of the digest, then the
# digest. It will be check on the server
digest_sent = mdhash_sent.digest()
digest_recv = mdhash_recv.digest()
# compute RTT statisticis
rtt_min = min(rtt_times)
rtt_max = max(rtt_times)
rtt_ave = float(sum(rtt_times)) / float(len(rtt_times))
total_time = final_stamp - zero_stamp
print(
"rel_client: echoed %d messages in %0.6f millisec min/max/ave RTT(msec) %.4f/%.4f/%.4f "
% (len(lines), total_time * 1000, rtt_min * 1000, rtt_max * 1000,
rtt_ave * 1000))
# compare the two digests, byte for byte
failed = False
for i, sent_byte in enumerate(digest_sent):
recv_byte = digest_recv[i]
if (sent_byte != recv_byte):
print("rel_client: digest failed at byte %d diff: %c %c " %
(i, sent_byte, recv_byte))
failed = True
if (not failed):
print("echo_client: digest succeeded")
fd.close()
def main():
global REALSYNC
# parse all the arguments to the client
if (sys.argv[0]):
prog_name = sys.argv[0]
else:
prog_name = 'rel_bw_test.py'
parser = argparse.ArgumentParser(description='CS 352 Socket Client')
parser.add_argument('-f','--filename', help='File to Echo', required=False)
parser.add_argument('-d','--destination', help='Destination IP Host', required=True)
parser.add_argument('-p','--remoteport', help='Remote sock352 UDP port', required=False)
parser.add_argument('-l','--localport', help='Local sock352 UDP port', required=True)
parser.add_argument('-s','--server', help='Run as server', action='store_true')
parser.add_argument('-x','--debuglevel', help='Debug Level')
parser.add_argument('-z','--dropprob', help='Drop Probability')
# get the arguments into local variables
args = vars(parser.parse_args())
filename = args['filename']
destinationIP = args['destination']
remote_port = args['remoteport']
local_port = int(args['localport'])
run_as_server = args['server']
# set the debug level. 0 = no debug statements, 10 = maximum debug output
if (args['debuglevel'] == None):
debug_level = 0
else:
debug_level = int(args['debuglevel'])
# set the drop probability. 0.0 = no data drops, 1.0 = drop everything
if (args['dropprob'] == None):
probability = 0.0
else:
probability = float(args['dropprob'])
# open the file for reading
#if (filename):
#try:
#filesize = os.path.getsize(filename)
#fd = open(filename, "rb")
#except:
#print ( "error opening file: %s" % (filename))
#exit(-1)
#else:
#pass
#rtt_times = []
# create a socket and connect to the remote server
s = sock352.Socket()
dest_addr = (destinationIP,int(remote_port))
# use the MD5 hash algorithm to validate all the data is correct
mdhash_sent = md5.new()
mdhash_recv = md5.new()
# a lines of lines to echo back
# for each line, take a time-stamp, send and recive the line, update the list of RTT times,
# and then update the MD5 hash of the sent and received data
# the maximum packet size for this transfer is 4K
max_pkt_size = (4*1024)
# set the debug level in the library
s.set_random_seed(352)
s.set_debug_level(debug_level)
s.set_drop_prob(probability)
# start time stamp to compute the bandwidth
zero_stamp = start_stamp = time.clock()
print "START STAMP:",start_stamp
ADDR = 0
SERVER = False
# run as a client or server
if (run_as_server):
s.bind(('', local_port))
#from_addr = s.accept()
#ADDR = from_addr
SERVER = True
else:
#s.connect(dest_addr)
ADDR = dest_addr
# the first message is the file size to send
#print "BYTES SEND:",bytes_to_send
lines = ' '
filesize=0
if (filename and SERVER==False):
try:
filesize = os.path.getsize(filename)
fd = open(filename, "rb")
lines = fd.readlines()
#fileinput.input(filename,inplace=1,mode="rb")
except:
print ( "error opening file: %s" % (filename))
exit(-1)
else:
pass
bytes_to_send=0
R = sock352.Packet()
send = 0
recv_size=0
#lines = fd.readlines()
num_lines = str(len(lines))
#zero_stamp = time.clock()
bytes_to_receive = 0
zero_stamp = time.clock()
s.set_drop_prob(probability)
sock352.drop_prob=probability
SYNCH = sock352.SYNC
from_addr = 0
#filesize=0
if SERVER==False:
#print "FILE:",lines
#sock352.Client=False
sock352.DATA=filesize
bytes_to_send=bytes_to_receive = int(filesize)
S1 = s.sendto('',dest_addr,1,False,False)
#return
print"DEST ADDR:",dest_addr
print"RECEIVED INITIALIZE:",S1
end_stamp = time.clock()
lapsed_seconds = float(end_stamp - zero_stamp)
line_number = int(num_lines)
i=0
Average=lapsed_seconds
print "FIRST MOVING AVERAGE:%.15f " % Average
#R = sock352.Packet()
print "ALL LINES:",filesize
print "DEST:",dest_addr
print "Probability:",probability
print "SELF PROB:",sock352.drop_prob
print "LIST OF OUST PACKETS...",sock352.list_of_outstanding_packets
SYNCH = sock352.SYNC
#bytes_
#recv_size=int(R.data)
#bytes_to_receive = filesize
#bytes_to_send = bytes_to_receive
else:
RECV = s.recvfrom(max_pkt_size,0)
print "RECV 000:",RECV
P = sock352.Packet()
sock352.ParsePack(RECV[0],P)
sock352.SYNC = P.seq
sock352.SetSock(P,P.cntl,P.data,True)
print "Server Sends Listen to client:",sock352.PrintPack(P)
from_addr = RECV[1]
s.sendto(P.toHexFields(),RECV[1],3,True,False)
print "Server--Client connection established."
bytes_to_send=bytes_to_receive = int(sock352.DATA)
#sock352.drop_prob=probability
end_stamp = time.clock()
lapsed_seconds = float(end_stamp - zero_stamp)
Average=lapsed_seconds
print "FIRST MOVING AVERAGE:%.15f:" % Average
print"DEST ADDR:",dest_addr
#FOR CLIENT
SEND1 = ''
#FOR SERVER
SEND2 = ''
print "BYTES TO RECEIVE:",bytes_to_receive
print "BYTES TO SEND:",bytes_to_send
#return
# loop until there are no bytes left to send or receive
i = 0
recv_data=0
Host =''
Port = 0
end_stamp = time.clock()
lapsed_seconds = float(end_stamp - zero_stamp)
print "MOVING AVG:",lapsed_seconds
print "DROP PROB:",probability
print "TOTAL FILE SIZE:",filesize
print "SERVER'S SYNC",sock352.SYN
print "CLIENT's SYNC:",sock352.SYNC
#return
if SERVER == True:
#global sock352.SYNC
print "SERVER SIDE"
total_bytes=bytes_to_receive
#Q=sock352.Packet()
#NEX = int(sock352.SYNC)+1
#print "NEXT:",NEX
##############################
#sock352.SYNC = NEX
##############################
while ((bytes_to_send > 0)):
print "BYTES TO SEND LEFT:",bytes_to_send
print "BYTES TO RECEIVE LEFT:",bytes_to_receive
if (bytes_to_send >= max_pkt_size):
size_to_send = max_pkt_size
else:
size_to_send = bytes_to_send
#T=sock352.Packet()
#T=Q
start_stamp = time.clock()
S2 = s.sendto(P.toHexFields(),from_addr,5,True,False)
#return
print "SERVER's SYNC:%d CLIENT's SYNC:%d" % (sock352.SYN,sock352.SYNC)
#print "\n\nDATA GOT:",S2
end_stamp = time.clock()
lapsed_seconds = float(end_stamp - start_stamp)
sock352.RTT_TIMES.append(lapsed_seconds)
sock352.RTT = float(sum(sock352.RTT_TIMES)) / float(len(sock352.RTT_TIMES))
print "SERV EST DATA LAPSED SECONDS:",lapsed_seconds
#################################
#sock352.SYNC = sock352.SYNC+1
sock352.IncrSYNC()
#################################
bytes_to_send = bytes_to_send - len(sock352.DATA)
bytes_to_receive = bytes_to_receive - len(S2)
#TT=binascii.hexlify(T.data)
mdhash_sent.update(binascii.hexlify(sock352.DATA))
mdhash_recv.update(binascii.hexlify(S2))
#break
i = i +1
if ((i % 100) == 0 ):
print ".",
print "BYTES TO SEND LEFT 2:",bytes_to_send
#break
#if i==1000:
#return
#print "BYTES TO RECEIVE LEFT:",bytes_to_receive
#print "THE DATA SENT:",T.data
#if(bytes_to_receive > 0):
#print "BYTES TO RECEIVE LEFT:",bytes_to_receive
#message = s.sockett.recvfrom(max_pkt_size)
#mdhash_recv.update(QQ)
else:
fd.seek(0)
print "CLIENT SIDE"
total_bytes=bytes_to_send
R = sock352.Packet()
SYNCH = sock352.SYNC
REALSYNC=SYNCH
while ( (bytes_to_send > 0) ):
#global sock352.SYNC
print "\n\nBYTES TO RECEIVE LEFT:",bytes_to_receive
print "\n\nBYTES TO SEND LEFT:",bytes_to_send
if (bytes_to_send >= max_pkt_size):
size_to_send = max_pkt_size
else:
size_to_send = bytes_to_send
bytes_to_receive=size_to_send
#R.cntl=start_stamp = time.clock()
X = fd.read(size_to_send)
sock352.DATA = X
#print "X DATA:",X
#break
S1 = s.sendto(R.toHexFields(),dest_addr,5,False,False)
#################################
sock352.SYN = sock352.SYN +1
#################################
#return
print "SERVER's SYNC:%d CLIENT's SYNC:%d" % (sock352.SYN,sock352.SYNC)
#print "%d\nDATA1:%s \nDATA 2:%s" % (size_to_send,S1,X)
#print "SERVER's SYNC:%d CLIENT's SYNC:%d" % (sock352.SYN,sock352.SYNC)
end_stamp = time.clock()
lapsed_seconds = float(end_stamp - start_stamp)
rtt_times.append(lapsed_seconds)
print "Lapsed seconds:",lapsed_seconds
Average = float(sum(rtt_times)) / float(len(rtt_times))
print "MOVING AVERAGE: %.4f Milisecs" % (Average*1000)
print "AVG GENERAL:%f " % (Average)
print "\n\n\n"
#sock352.rtt_times=rtt_times
#Successfully received data
bytes_to_send=bytes_to_send - len(sock352.DATA)
bytes_to_receive=bytes_to_receive - len(X)
#RR = binascii.hexlify(R.data)
#print "R",R.data
#print "Y",Y.data
mdhash_recv.update(binascii.hexlify(X))
mdhash_sent.update(binascii.hexlify(sock352.DATA))
#return
#send_data = fd.read(size_to_send)
#send = s.sendto(send_data)
#bytes_to_send = bytes_to_send - size_to_send
#mdhash_sent.update(send_data)
i = i +1
if ((i % 100) == 0 ):
print ".",
rtt_ave = float(sum(rtt_times)) / float(len(rtt_times))
print "CURR RTT AVG + offset:",rtt_ave
#sock352.RTT=Average
#break
#if (bytes_to_receive > 0):
#recv_data = s.recvfrom(max_pkt_size)
#bytes_to_receive = bytes_to_receive - len(recv_data)
#mdhash_recv.update(recv_data)
print "\n\n\n"
#s.sendto("ACK",dest_addr)
#return
print "MADE IT"
digest_sent = mdhash_sent.digest()
digest_recv = mdhash_recv.digest()
print "MADE IT"
sock352.list_of_outstanding_packets = []
#FINAL SEND TO ACKNOWLEDGE ALL DATA
# send = s.sockett.sendto(digest_recv,RECV,5)
# REMOTE DIGEST IS OTHER's DIGEST RECEIVED, ECHO
#remote_digest = s.recvfrom(max_pkt_size)
#return
#send = s.sendto(digest_recv,RECV,6)
if(SERVER):
print "RECEIVE"
Found = False
remote_digest = 0
remote_digest1 = 0
while (not Found):
remote_digest1 = s.recvfrom(max_pkt_size,0)
print "REMOTE DIG:",remote_digest1
try:
Found = True
remote_digest = binascii.unhexlify(remote_digest1[0])
except:
Found = False
P = sock352.Packet()
sock352.SetSock(P,1,'',True)
P.cntl = 8
print "FINAL PACK:",sock352.PrintPack(P)
s.sockett.sendto(P.toHexFields(),from_addr)
#return
#remote_digest1 = s.sockett.recvfrom(max_pkt_size)
#remote_digest1 = s.sockett.recvfrom(max_pkt_size)
P = sock352.Packet()
#print "REMOTE DIGEST 1:",remote_digest1
#sock352.ParsePack(remote_digest1[0],P)
Dig = binascii.hexlify(digest_sent)
#sock352.ParsePack(remote_digest1[0],P)
#print "P DIGEST:",P.data
print "MY DIGEST:",Dig
#return
#remote_digest = binascii.unhexlify(P.data)
#Found = False
#while (not Found):
#remote_digest1 = s.sockett.recvfrom(max_pkt_size)
#try:
#Found = True
#remote_digest = binascii.unhexlify(remote_digest1)
#except:
#Found = False
#print "REMOTE_DIGEST",remote_digest
s.close()
end_stamp = time.clock()
lapsed_seconds = float(end_stamp - zero_stamp)
#fd.close()
#print "MADE IT"
print "rel: sent digest: x%s received digest x%s remote digest x%s " % (binascii.hexlify(str(digest_sent)), binascii.hexlify(str(digest_recv)), binascii.hexlify(str(remote_digest)))
# this part send the lenght of the digest, then the
# digest. It will be check on the server
# compute bandwidthstatisticis
total_time = float(end_stamp) - float(zero_stamp)
print "TOTAL TIME:%.10f" % total_time
#return
try:
bandwidth = ((total_bytes)/ (total_time))/1000000.0
except:
print "ERROR, DIVIDE BY 0"
return
# make sure the digest from the remote side matches what we sent
failed = False;
for i, sent_byte in enumerate(digest_sent):
remote_byte = remote_digest[i]
if (sent_byte != remote_byte):
print( "%s: digest failed at byte %d diff: %c %c " % (prog_name,i,sent_byte,remote_byte))
failed = True;
if (not failed):
print( "%s: digest succeeded bandwidth %f Mbytes/sec" % (prog_name,bandwidth) )
else:
fd.close()
digest_sent = mdhash_sent.digest()
digest_recv = mdhash_recv.digest()
digest_recv2 = mdhash_recv.hexdigest()
Dig = binascii.hexlify(digest_recv)
Dig2 = binascii.hexlify(digest_sent)
print "DIGEST RECV:",Dig
print "DIGEST SENT:",Dig2
Y = sock352.Packet()
Y.cntl = 6
#print "\n FINAL DIGEST:\n:",digest_recv[0]
Y.data = str(digest_recv2)
while(1):
send = s.sockett.sendto(Dig,dest_addr)
try:
R1 = s.recvfrom(max_pkt_size,0)
except:
print "Waited too long..."
sock352.ParsePack(R1[0],Y)
#sock352.PrintPack(Y)
if(Y.cntl==8):
print "Final Packet, confirmed"
break
#send = s.sendto(str(Y.toHexFields()),(str(Y.data),dest_addr),6)
#return
s.close()
final_stamp = end_stamp
#digest_recv=binascii.unhexlify(digest_recv2)
# compute RTT statisticis
rtt_min = min(rtt_times)
rtt_max = max(rtt_times)
rtt_ave = float(sum(rtt_times)) / float(len(rtt_times))
total_time = final_stamp - zero_stamp
print ("rel_client: echoed %d bytes in %0.6f millisec min/max/ave RTT(msec) %.4f/%.4f/%.4f " %
(total_bytes, total_time*1000, rtt_min*1000,rtt_max*1000,rtt_ave*1000))
# compare the two digests, byte for byte
failed = False;
for i, sent_byte in enumerate(digest_sent):
recv_byte = digest_recv[i]
#print "Recv:%x Sent:%x",recv_byte,sent_byte
if (sent_byte != recv_byte):
print( "rel_client: digest failed at byte %d diff: %c %c " % (i,sent_byte,recv_byte))
failed = True;
if (not failed):
print( "echo_client: digest succeeded")
fd.close()
E = sock352.Packet()
#S = s.sendto(E.toHexFields(),dest_addr,8,False,False)
# this makes sure all threads exit
os._exit(1)
def main():
# parse all the arguments to the client
parser = argparse.ArgumentParser(description='CS 352 Socket Client')
parser.add_argument('-f','--filename', help='File to Echo', required=False)
parser.add_argument('-d','--destination', help='Destination IP Host', required=True)
parser.add_argument('-p','--remoteport', help='remote sock352 UDP port', required=False)
parser.add_argument('-l','--localport', help='local sock352 UDP port', required=True)
parser.add_argument('-x','--debuglevel', help='Debug Level')
parser.add_argument('-z','--dropprob', help='Drop Probability')
# get the arguments into local variables
debug_level = 0
args = vars(parser.parse_args())
filename = args['filename']
destinationIP = args['destination']
remote_port = args['remoteport']
local_port = args['localport']
# set the debug level. 0 = no debug statements, 10 = maximum debug output
if (args['debuglevel'] == None):
debug_level = 0
else:
debug_level = int(args['debuglevel'])
# set the drop probability. 0.0 = no data drops, 1.0 = drop everything
if (args['dropprob'] == None):
probability = 0.0
else:
probability = float(args['dropprob'])
# open the file for reading
if (filename):
try:
filesize = os.path.getsize(filename)
fd = open(filename, "rb")
except:
print ( "error opening file: %s" % (filename))
exit(-1)
else:
pass
sock352.Client=True
# max size of the data payload is 63 KB
MAX_SIZE = (63*1024)
# max size of the packet with the headers
MAX_PKT = ((16+16+16)+(MAX_SIZE))
# create a socket and connect to the remote server
s = sock352.Socket()
sock352.CLIENT=True
# set the debug level in the library
s.set_random_seed(352)
s.set_debug_level(debug_level)
s.set_drop_prob(probability)
sock352.drop_prob = probability
dest_addr = (destinationIP,int(remote_port))
# use the MD5 hash algorithm to validate all the data is correct
mdhash_sent = md5.new()
mdhash_recv = md5.new()
# a lines of lines to echo back
lines = fd.readlines()
rtt_times = []
# for each line, take a time-stamp, send and recive the line, update the list of RTT times,
# and then update the MD5 hash of the sent and received data
zero_stamp = time.clock()
s.connect(dest_addr)
s.set_drop_prob(probability)
num_lines = str(len(lines))
sock352.Lines=int(len(lines))
E = sock352.Packet()
E.cntl = 1
sock352.DATA=int(len(lines))
S1 = s.sendto('',dest_addr,1,False,False)
#return
print"DEST ADDR:",dest_addr
print"RECEIVED INITIALIZE:",S1
end_stamp = time.clock()
lapsed_seconds = float(end_stamp - zero_stamp)
line_number = int(num_lines)
i=0
Average=lapsed_seconds
print "FIRST MOVING AVERAGE:%.15f " % Average
#R = sock352.Packet()
print "ALL LINES:",num_lines
print "DEST:",dest_addr
print "Probability:",probability
print "SELF PROB:",sock352.drop_prob
print "LIST OF OUST PACKETS...",sock352.list_of_outstanding_packets
#sock352.DATA = lines[0]
#print "DATA SET:",sock352.DATA
#P = sock352.Packet()
#S1 = s.sendto(P.toHexFields(),dest_addr,5,False,False)
#print "FIRST DATA:",S1
#sock352.DATA = lines[1]
#print "DATA SET:",sock352.DATA
#S1 = s.sendto(P.toHexFields(),dest_addr,5,False,False)
#print "FIRST DATA:",S1
#sock352.DATA = lines[2]
#print "DATA SET:",sock352.DATA
#S1 = s.sendto(P.toHexFields(),dest_addr,5,False,False)
#print "FIRST DATA:",S1
#return
Q = sock352.Packet()
for line in lines:
start_stamp = time.clock()
if (debug_level > 0):
print "rel_client -- sending line %d: %s" % (line_number,line)
sock352.DATA = line
print "DATA SET:",sock352.DATA
P = sock352.Packet()
S1 = s.sendto(P.toHexFields(),dest_addr,5,False,False)
print "%d DATA:%s" % (line_number,S1)
print "SERVER's SYNC:%d CLIENT's SYNC:%d" % (sock352.SYN,sock352.SYNC)
end_stamp = time.clock()
lapsed_seconds = float(end_stamp - start_stamp)
rtt_times.append(lapsed_seconds)
#################################
sock352.SYN = sock352.SYN+1
#################################
print "Lapsed seconds:",lapsed_seconds
line_number = line_number - 1
print "Lines Left:",line_number
# update the sent and received data
mdhash_sent.update((line))
Q.data=sock352.DATA
print "ECHO:",Q.data
mdhash_recv.update((Q.data))
if similar(str(Q.data),line)>=1:
print "MATCH!"
Average = float(sum(rtt_times)) / float(len(rtt_times))
print "MOVING AVERAGE: %.4f Milisecs" % (Average*1000)
print "AVG GENERAL:%f " % (Average)
print "\n\n\n"
#i = i+1
# this allows use to time the entire loop, not just every RTT
# Allows estimation of the protocol delays
# this part send the lenght of the digest, then the
# digest. It will be check on the server
digest_sent = mdhash_sent.digest()
digest_recv = mdhash_recv.digest()
digest_recv2 = mdhash_recv.hexdigest()
print "DIGEST RECV:",digest_recv
Y = sock352.Packet()
Y.cntl = 6
#print "\n FINAL DIGEST:\n:",digest_recv[0]
Y.data = str(digest_recv2)
#send = s.sendto(str(Y.toHexFields()),(str(Y.data),dest_addr),6)
s.close()
final_stamp = end_stamp
# compute RTT statisticis
rtt_min = min(rtt_times)
rtt_max = max(rtt_times)
rtt_ave = float(sum(rtt_times)) / float(len(rtt_times))
total_time = final_stamp - zero_stamp
print ("rel_client: echoed %d messages in %0.6f millisec min/max/ave RTT(msec) %.4f/%.4f/%.4f " %
(len(lines), total_time*1000, rtt_min*1000,rtt_max*1000,rtt_ave*1000))
# compare the two digests, byte for byte
failed = False;
for i, sent_byte in enumerate(digest_sent):
recv_byte = digest_recv[i]
#print "Recv:%x Sent:%x",recv_byte,sent_byte
if (sent_byte != recv_byte):
print( "rel_client: digest failed at byte %d diff: %c %c " % (i,sent_byte,recv_byte))
failed = True;
if (not failed):
print( "echo_client: digest succeeded")
fd.close()
def main():
# parse all the arguments to the client
parser = argparse.ArgumentParser(description='CS 352 Socker Echo Server ')
parser.add_argument('-l',
'--localport',
help='local sock352 UDP port',
required=True)
parser.add_argument('-x', '--debuglevel', help='Debug Level')
parser.add_argument('-z', '--dropprob', help='Drop Probability')
args = vars(parser.parse_args())
local_port = int(args['localport'])
# set the debug level. 0 = no debug statements, 10 = maximum debug output
if (args['debuglevel'] == None):
debug_level = 0
else:
debug_level = int(args['debuglevel'])
# set the drop probability. 0.0 = no data drops, 1.0 = drop everything
if (args['dropprob'] == None):
probability = 0.0
else:
probability = float(args['dropprob'])
sock352.CLIENT = False
serverSock = sock352.Socket()
serverSock.bind(('', local_port))
# set the debug level in the library
serverSock.set_random_seed(352)
serverSock.set_debug_level(debug_level)
serverSock.set_drop_prob(probability)
#L = serverSock.listen(0)
#print "ACCEPT:",L
#from_addr = serverSock.accept()
#print "Accepted",from_addr
#INIT
#sock352.Client=False
sock352.drop_prob = probability
RECV = serverSock.recvfrom(MAX_SIZE, 0)
print "RECV 000:", RECV
#return
P = sock352.Packet()
sock352.ParsePack(RECV[0], P)
sock352.SYNC = P.seq
sock352.SetSock(P, P.cntl, P.data, True)
print "Server Sends Listen to client:", sock352.PrintPack(P)
serverSock.sendto(P.toHexFields(), RECV[1], 3, True, False)
print "Server--Client connection established."
line_count = int(sock352.DATA)
#S2 = serverSock.sendto(P.toHexFields(),RECV[1],5,True,False)
#print "SERVER's SYNC:%d CLIENT's SYNC:%d" % (sock352.SYN,sock352.SYNC)
#################################
#sock352.SYNC = sock352.SYNC+1
#################################
#S2 = serverSock.sendto(P.toHexFields(),RECV[1],5,True,False)
#print "SERVER's SYNC:%d CLIENT's SYNC:%d" % (sock352.SYN,sock352.SYNC)
#################################
#sock352.SYNC = sock352.SYNC+1
#################################
#S2 = serverSock.sendto(P.toHexFields(),RECV[1],5,True,False)
#print "SERVER's SYNC:%d CLIENT's SYNC:%d" % (sock352.SYN,sock352.SYNC)
#return
while (line_count > 0):
#Read from UDP socket into message, client address
#message = serverSock.recvfrom(MAX_SIZE,None)
#print ("server -- got packet len %d line %s" % (len(message[0]),message))
start_stamp = time.clock()
S2 = serverSock.sendto(P.toHexFields(), RECV[1], 5, True, False)
print "SERVER's SYNC:%d CLIENT's SYNC:%d" % (sock352.SYN, sock352.SYNC)
print "\n\nDATA GOT:", S2
end_stamp = time.clock()
lapsed_seconds = float(end_stamp - start_stamp)
sock352.RTT_TIMES.append(lapsed_seconds)
sock352.RTT = float(sum(sock352.RTT_TIMES)) / float(
len(sock352.RTT_TIMES))
print "SERV EST DATA LAPSED SECONDS:", lapsed_seconds
#################################
sock352.SYNC = sock352.SYNC + 1
#################################
line_count = line_count - 1
print("server -- %d lines to go " % (line_count))
print "\n\n\n"
#return
#time.sleep(2)
#message = serverSock.sockett.recvfrom(MAX_SIZE)
Close = False
