def main():
# parse all the arguments to the client
parser = argparse.ArgumentParser(description='CS 352 Socket Server')
parser.add_argument('-f',
'--filename',
help='Filename to Receiver',
required=False)
parser.add_argument('-p',
'--port',
help='CS 352 Socket Port (optional for part 1)',
required=False)
parser.add_argument('-u',
'--udpportRx',
help='UDP port to use for receiving',
required=True)
parser.add_argument('-v',
'--udpportTx',
help='UDP port to use for sending',
required=False)
args = vars(parser.parse_args())
# open the file for writing
filename = args['filename']
udpportRx = args['udpportRx']
if (args['udpportTx']):
udpportTx = args['udpportTx']
else:
udpportTx = ''
# the port is not used in part 1 assignment, except as a placeholder
if (args['port']):
port = args['port']
else:
port = 1111
if (filename):
try:
fd = open(filename, "wb")
usefile = True
except:
print("error opening file: %s" % (filename))
exit(-1)
else:
pass
# This is where we set the transmit and receive
# ports the server uses for the underlying UDP
# sockets. If we are running the client and
# server on different machines, these ports
# need to be different, otherwise we can
# use the same ports
if (udpportTx):
sock352.init(udpportTx, udpportRx)
else:
sock352.init(udpportRx, udpportRx)
s = sock352.socket()
# set the fragment size we will read on
# FRAGMENTSIZE = 4096
# binding the host to empty allows reception on
# all network interfaces
s.bind(('', port))
s.listen(5)
# when accept returns, the client is connected
(s2, address) = s.accept()
# this receives the size of the file
# as a 4 byte integer in network byte order (big endian)
longPacker = struct.Struct("!L")
long = s2.recv(4)
fn = longPacker.unpack(long)
filelen = fn[0]
#print("Filelen: ", filelen)
# # the MD5 computes a unique hash for all the data
# mdhash = md5.new()
# bytes_to_receive = filelen
start_stamp = time.clock()
# main loop to receive the data from the client
# while (bytes_to_receive > 0):
# if (bytes_to_receive >= FRAGMENTSIZE):
# fragment = s2.recv(FRAGMENTSIZE)
# else:
# fragment = s2.recv(bytes_to_receive)
# mdhash.update(fragment)
# bytes_to_receive = bytes_to_receive - len(fragment)
# fd.write(fragment)
file = s2.recv(filelen)
# mdhash.update(file)
fd.write(file)
end_stamp = time.clock()
lapsed_seconds = end_stamp - start_stamp
# finish computing the MD5 hash
# local_digest = mdhash.digest()
# receive the size of the remote hash
# dl = longPacker.unpack(s2.recv(4))
# digestlen = dl[0]
# remote_digest = s2.recv(digestlen)
# # check is the size matches
# if (len(remote_digest) != digestlen):
# raise RuntimeError("socket error")
# # compare the two digests, byte for byte
# for i, server_byte in enumerate(local_digest):
# client_byte = remote_digest[i]
# if (client_byte != server_byte):
# print( "digest failed at byte %d %c %c " % (i,client_byte,server_byte))
if (lapsed_seconds > 0.0):
print("server1: received %d bytes in %0.6f seconds, %0.6f MB/s " %
(filelen, lapsed_seconds,
(filelen / lapsed_seconds) / (1024 * 1024)))
else:
print("server1: received %d bytes in %d seconds, inf MB/s " %
(filelen, lapsed_seconds))
fd.close()
s2.close()
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 Send',
required=False)
parser.add_argument('-d',
'--destination',
help='Destination IP Host',
required=True)
parser.add_argument('-p',
'--port',
help='remote sock352 port',
required=False)
parser.add_argument('-u',
'--udpportRx',
help='UDP port to use for receiving',
required=True)
parser.add_argument('-v',
'--udpportTx',
help='UDP port to use for sending',
required=False)
# get the arguments into local variables
args = vars(parser.parse_args())
filename = args['filename']
destination = args['destination']
udpportRx = args['udpportRx']
if (args['udpportTx']):
udpportTx = args['udpportTx']
else:
udpportTx = ''
# the port is not used in part 1 assignment, except as a placeholder
if (args['port']):
port = args['port']
else:
port = 1111
# open the file for reading
if (filename):
try:
filesize = os.path.getsize(filename)
fd = open(filename, "rb")
usefile = True
except:
print("error opening file: %s" % (filename))
exit(-1)
else:
pass
# This is where we set the transmit and receive
# ports the client uses for the underlying UDP
# sockets. If we are running the client and
# server on the same machine, these ports
# need to be different. If they are running on
# different machines, we can re-use the same
# ports.
if (udpportTx):
sock352.init(udpportTx, udpportRx)
else:
sock352.init(udpportRx, udpportRx)
s = sock352.socket()
s.connect((destination, port))
longPacker = struct.Struct("!L")
fileLenPacked = longPacker.pack(filesize)
s.send(fileLenPacked)
bytes_to_send = filesize
start_stamp = time.clock()
file_contents = fd.read()
totalsent = 0
# make sure we sent the whole fragment
totalsent = s.send(file_contents)
if (totalsent == 0):
raise RuntimeError("socket broken")
end_stamp = time.clock()
lapsed_seconds = end_stamp - start_stamp
if (lapsed_seconds > 0.0):
print("client1: sent %d bytes in %0.6f seconds, %0.6f MB/s " %
(filesize, lapsed_seconds,
(filesize / lapsed_seconds) / (1024 * 1024)))
else:
print("client1: sent %d bytes in %d seconds, inf MB/s " %
(filesize, lapsed_seconds))
fd.close()
s.close()
def main():
# parse all the arguments to the client
parser = argparse.ArgumentParser(description='CS 352 Socket Server')
parser.add_argument('-f',
'--filename',
help='Filename to Receiver',
required=False)
parser.add_argument('-p',
'--port',
help='CS 352 Socket Port (optional for part 1)',
required=False)
parser.add_argument('-u',
'--udpportRx',
help='UDP port to use for receiving',
required=True)
parser.add_argument('-v',
'--udpportTx',
help='UDP port to use for sending',
required=False)
args = vars(parser.parse_args())
# open the file for writing
filename = args['filename']
udpportRx = args['udpportRx']
if (args['udpportTx']):
udpportTx = args['udpportTx']
else:
udpportTx = ''
# the port is not used in part 1 assignment, except as a placeholder
if (args['port']):
port = args['port']
else:
port = 1111
if (filename):
try:
fd = open(filename, "wb")
usefile = True
except:
print("error opening file: %s" % (filename))
exit(-1)
else:
pass
# This is where we set the transmit and receive
# ports the server uses for the underlying UDP
# sockets. If we are running the client and
# server on different machines, these ports
# need to be different, otherwise we can
# use the same ports
if (udpportTx):
sock352.init(udpportTx, udpportRx)
else:
sock352.init(udpportRx, udpportRx)
s = sock352.socket()
# binding the host to empty allows reception on
# all network interfaces
s.bind(('', port))
s.listen(5)
# when accept returns, the client is connected
(s2, address) = s.accept()
# this receives the size of the file
# as a 4 byte integer in network byte order (big endian)
longPacker = struct.Struct("!L")
long = s2.recv(4)
fn = longPacker.unpack(long)
filelen = fn[0]
start_stamp = time.clock()
file = s2.recv(filelen)
fd.write(file)
end_stamp = time.clock()
lapsed_seconds = end_stamp - start_stamp
if (lapsed_seconds > 0.0):
print("server1: received %d bytes in %0.6f seconds, %0.6f MB/s " %
(filelen, lapsed_seconds,
(filelen / lapsed_seconds) / (1024 * 1024)))
else:
print("server1: received %d bytes in %d seconds, inf MB/s " %
(filelen, lapsed_seconds))
fd.close()
s2.close()
import sock352
import time
sock352.init(0, 0)
s = sock352.socket()
s.connect(('127.0.0.1', 12467))
print(time.time())
def main():
# parse all the arguments to the client
global fd
parser = argparse.ArgumentParser(description='CS 352 Socket Server')
parser.add_argument('-f',
'--filename',
help='Filename to Receiver',
required=False)
parser.add_argument('-p',
'--port',
help='CS 352 Socket Port (optional for part 1)',
required=False)
parser.add_argument('-u',
'--udpportRx',
help='UDP port to use for receiving',
required=True)
parser.add_argument('-v',
'--udpportTx',
help='UDP port to use for sending',
required=False)
args = vars(parser.parse_args())
# open the file for writing
filename = args['filename']
udpportRx = args['udpportRx']
if (args['udpportTx']):
udpportTx = args['udpportTx']
else:
udpportTx = ''
# the port is not used in part 1 assignment, except as a placeholder
if (args['port']):
port = args['port']
else:
port = 1111
if (filename):
try:
fd = open(filename, "wb")
usefile = True
except:
print("error opening file: %s" % (filename))
exit(-1)
else:
pass
# This is where we set the transmit and receive
# ports the server uses for the underlying UDP
# sockets. If we are running the client and
# server on different machines, these ports
# need to be different, otherwise we can
# use the same ports
if (udpportTx):
sock352.init(udpportTx, udpportRx)
else:
sock352.init(udpportRx, udpportRx)
s = sock352.socket()
# set the maximum fragment size we will read on
MAXFRAGMENTSIZE = 16384
# binding the host to empty allows reception on
# all network interfaces
s.bind(('', port))
s.listen(5)
# when accept returns, the client is connected
(s2, address) = s.accept()
# this receives the size of the file
# as a 4 byte integer in network byte order (big endian)
longPacker = struct.Struct("!L")
long = s2.recv(4)
fn = longPacker.unpack(long)
filelen = fn[0]
# the MD5 computes a unique hash for all the data
bytes_to_receive = filelen
start_stamp = time.perf_counter()
random.seed(a=352)
# main loop to receive the data from the client
while bytes_to_receive > 0:
size = random.randrange(1, MAXFRAGMENTSIZE)
if bytes_to_receive >= size:
# pick a random size to receive
fragment = s2.recv(size)
else:
fragment = s2.recv(bytes_to_receive)
bytes_to_receive = bytes_to_receive - len(fragment)
fd.write(fragment)
end_stamp = time.perf_counter()
lapsed_seconds = end_stamp - start_stamp
if lapsed_seconds > 0.0:
print("server1: received %d bytes in %0.6f seconds, %0.6f MB/s " %
(filelen, lapsed_seconds,
(filelen / lapsed_seconds) / (1024 * 1024)))
else:
print("server1: received %d bytes in %d seconds, inf MB/s " %
(filelen, lapsed_seconds))
fd.close()
s2.close()
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 Send',
required=False)
parser.add_argument('-d',
'--destination',
help='Destination IP Host',
required=True)
parser.add_argument('-p',
'--port',
help='remote sock352 port',
required=False)
parser.add_argument('-u',
'--udpportRx',
help='UDP port to use for receiving',
required=True)
parser.add_argument('-v',
'--udpportTx',
help='UDP port to use for sending',
required=False)
# get the arguments into local variables
args = vars(parser.parse_args())
filename = args['filename']
destination = args['destination']
udpportRx = args['udpportRx']
if (args['udpportTx']):
udpportTx = args['udpportTx']
else:
udpportTx = ''
# the port is not used in part 1 assignment, except as a placeholder
if (args['port']):
port = args['port']
else:
port = 1300
# open the file for reading
if (filename):
try:
filesize = os.path.getsize(filename)
fd = open(filename, "rb")
usefile = True
except:
print("error opening file: %s" % (filename))
exit(-1)
else:
pass
# This is where we set the transmit and receive
# ports the client uses for the underlying UDP
# sockets. If we are running the client and
# server on the same machine, these ports
# need to be different. If they are running on
# different machines, we can re-use the same
# ports.
if (udpportTx):
sock352.init(udpportTx, udpportRx)
else:
sock352.init(udpportRx, udpportRx)
# create a socket and connect to the remote server
s = sock352.socket()
s.connect((destination, port))
# send the size of the file as a 4 byte integer
# to the server, so it knows how much to read
FRAGMENTSIZE = 8192
longPacker = struct.Struct("!L")
fileLenPacked = longPacker.pack(filesize)
s.send(fileLenPacked)
# use the MD5 hash algorithm to validate all the data is correct
mdhash = md5.new()
# loop for the size of the file, sending the fragments
bytes_to_send = filesize
start_stamp = time.clock()
while (bytes_to_send > 0):
fragment = fd.read(FRAGMENTSIZE)
mdhash.update(fragment)
totalsent = 0
# make sure we sent the whole fragment
while (totalsent < len(fragment)):
sent = s.send(fragment[totalsent:])
if (sent == 0):
raise RuntimeError("socket broken")
totalsent = totalsent + sent
bytes_to_send = bytes_to_send - len(fragment)
end_stamp = time.clock()
lapsed_seconds = end_stamp - start_stamp
# this part send the lenght of the digest, then the
# digest. It will be check on the server
digest = mdhash.digest()
# send the length of the digest
long = len(digest)
digestLenPacked = longPacker.pack(long)
sent = s.send(digestLenPacked)
if (sent != 4):
raise RuntimeError("socket broken")
# send the digest
sent = s.send(digest)
if (sent != len(digest)):
raise RuntimeError("socket broken")
if (lapsed_seconds > 0.0):
print("client1: sent %d bytes in %0.6f seconds, %0.6f MB/s " %
(filesize, lapsed_seconds,
(filesize / lapsed_seconds) / (1024 * 1024)))
else:
print("client1: sent %d bytes in %d seconds, inf MB/s " %
(filesize, lapsed_seconds))
fd.close()
s.close()
import sock352
sock352.init(38912, 38911)
socket = sock352.socket()
# Server will drop 20% of the packets it sends.
socket.dropPercentage = 0
print "Binding..."
socket.bind(('', 1010))
print "Listening..."
socket.listen(5)
print "Accepting..."
socket.accept()
print "Receiving..."
data = socket.recv(488890)
print "Sending: " + data[:20] + "..." + data[-20:]
ret = socket.send(data)
print "Sent."
print "Closing socket..."
socket.close()
print "Closed socket."
#fuser 8888/udp <-- finds udp port 8888 being used
#fuser -k 8888/udp <-- kills process running on port 8888
import sock352
import struct
sock352.init(9993, 8883)
(publicKeys, privateKeys) = sock352.readKeyChain('keychain.txt')
sock = sock352.socket()
sock.bind(('', 1111))
sock.listen(1)
(s, address) = sock.accept(sock352.ENCRYPT)
longPacker = struct.Struct("!L")
long = s.recv(4)
fn = longPacker.unpack(long)
size = fn[0]
message = s.recv(size)
print("Received: " + message)
s.close()
import sock352
sock352.init(8888, 9999)
s = sock352.socket()
s.connect(('127.0.0.1', 1111))
b = s.send(
"Style never met and those among great. At no or september sportsmen he perfectly happiness attending. Depending listening delivered off new she procuring satisfied sex existence. Person plenty answer to exeter it if. Law use assistance especially resolution cultivated did out sentiments unsatiable. Way necessary had intention happiness but september delighted his curiosity. Furniture furnished or on strangers neglected remainder engrossed."
)
print("Sent " + str(b) + " bytes")
s.close()
#fuser 8888/udp <-- finds udp port 8888 being used
#fuser -k 8888/udp <-- kills process running on port 8888
import sock352
sock352.init(9999, 8888)
sock = sock352.socket()
sock.bind(('', 1111))
sock.listen(1)
(s, address) = sock.accept()
message = s.recv(443)
print("Received: " + message)
s.close()
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 Send', required=False)
parser.add_argument('-d','--destination', help='Destination IP Host', required=True)
parser.add_argument('-p','--port', help='remote sock352 port', required=False)
parser.add_argument('-u','--udpportRx', help='UDP port to use for receiving', required=True)
parser.add_argument('-v','--udpportTx', help='UDP port to use for sending', required=False)
parser.add_argument('-k','--keyfile', help='keyfile', required=True)
# get the arguments into local variables
args = vars(parser.parse_args())
filename = args['filename']
destination = args['destination']
udpportRx = args['udpportRx']
keyfilename = args['keyfile']
if (args['udpportTx']):
udpportTx = args['udpportTx']
else:
udpportTx = ''
# the port is not used in part 2 assignment, except as a placeholder
if (args['port']):
port = args['port']
else:
port = 5555
# open the file to send to the server for reading
if (filename):
try:
filesize = os.path.getsize(filename)
fd = open(filename, "rb")
usefile = True
except:
print ( "error opening file: %s" % (filename))
exit(-1)
else:
pass
# This is where we set the transmit and receive
# ports the client uses for the underlying UDP
# sockets. If we are running the client and
# server on the same machine, these ports
# need to be different. If they are running on
# different machines, we can re-use the same
# ports.
if (udpportTx):
sock352.init(udpportTx,udpportRx)
else:
sock352.init(udpportRx,udpportRx)
# load a keychain from a file
keysInHex = sock352.readKeyChain(keyfilename)
# create a socket and connect to the remote server
s = sock352.socket()
s.connect((destination,port),sock352.ENCRYPT)
# Comment above and uncomment below to toggle encryption
#s.connect((destination,port))
#mesure the start stamp
start_stamp = time.clock()
#load the whole file into memory
whole_file = fd.read()
#mesure its length
filesize = len(whole_file)
longPacker = struct.Struct("!L")
fileLenPacked = longPacker.pack(filesize);
s.send(fileLenPacked)
sent = s.send(whole_file)
if (sent != filesize):
raise RuntimeError("socket broken")
end_stamp = time.clock()
lapsed_seconds = end_stamp - start_stamp
if (lapsed_seconds > 0.0):
print ("client1: sent %d bytes in %0.6f seconds, %0.6f MB/s " % (filesize, lapsed_seconds, (filesize/lapsed_seconds)/(1024*1024)))
else:
print ("client1: sent %d bytes in %d seconds, inf MB/s " % (filesize, lapsed_seconds))
fd.close()
s.close()
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 Send',
required=False)
parser.add_argument('-d',
'--destination',
help='Destination IP Host',
required=True)
parser.add_argument('-p',
'--port',
help='remote sock352 port',
required=False)
parser.add_argument('-u',
'--udpportRx',
help='UDP port to use for receiving',
required=True)
parser.add_argument('-v',
'--udpportTx',
help='UDP port to use for sending',
required=False)
# get the arguments into local variables
args = vars(parser.parse_args())
filename = args['filename']
destination = args['destination']
udpportRx = args['udpportRx']
if (args['udpportTx']):
udpportTx = args['udpportTx']
else:
udpportTx = ''
# the port is not used in part 1 assignment, except as a placeholder
if (args['port']):
port = args['port']
else:
port = 5555
# open the file to send to the server for reading
if (filename):
try:
filesize = os.path.getsize(filename)
fd = open(filename, "rb")
usefile = True
except:
print("error opening file: %s" % (filename))
exit(-1)
else:
pass
# This is where we set the transmit and receive
# ports the client uses for the underlying UDP
# sockets. If we are running the client and
# server on the same machine, these ports
# need to be different. If they are running on
# different machines, we can re-use the same
# ports.
if (udpportTx):
sock352.init(udpportTx, udpportRx)
else:
sock352.init(udpportRx, udpportRx)
# create a socket and connect to the remote server
s = sock352.socket()
s.connect((destination, port))
BUFFERSIZE = 268288
longPacker = struct.Struct("!L")
fileLenPacked = longPacker.pack(filesize)
s.send(fileLenPacked)
mdhash = md5()
bytes_to_send = filesize
start_stamp = time.process_time()
while (bytes_to_send > 0):
buff = fd.read(BUFFERSIZE)
mdhash.update(buff)
totalsent = 0
while (totalsent < len(buff)):
sent = s.send(buff[totalsent:])
if (sent == 0):
raise RuntimeError("broken socket")
totalsent = totalsent + sent
bytes_to_send = bytes_to_send - len(buff)
end_stamp = time.process_time()
lapsed_seconds = end_stamp - start_stamp
digest = mdhash.digest()
long = len(digest)
digestLenPacked = longPacker.pack(long)
sent = s.send(digestLenPacked)
if (sent != 4):
raise RuntimeError("socket broken")
sent = s.send(digest)
if (sent != len(digest)):
raise RuntimeError("socket broken")
if (lapsed_seconds > 0.0):
print("client1: sent %d bytes in %0.6f seconds, %0.6f MB/s " %
(filesize, lapsed_seconds,
(filesize / lapsed_seconds) / (1024 * 1024)))
else:
print("client1: sent %d bytes in %d seconds, inf MB/s " %
(filesize, lapsed_seconds))
fd.close()
s.close()
import sock352
import struct
sock352.init('8000', '3221')
mysocket = sock352.socket()
givenHeader = mysocket.connect(("localhost", 1111))
x = struct.unpack("!12B", givenHeader)
print(x)
import sock352
import struct
import socket as syssock
sock352.init(8883, 9993)
keysInHex = sock352.readKeyChain('keychain.txt')
s = sock352.socket()
s.connect(('127.0.0.1', 1111), sock352.ENCRYPT)
message = b"I never offered Pardons to Homeland Security Officials, never ordered anyone to close our Southern Border (although I have the absolute right to do so, and may if Mexico does not apprehend the illegals coming to our Border), and am not \"frustrated.\" It is all Fake & Corrupt News!"
size = len(message)
longPacker = struct.Struct("!L")
package = longPacker.pack(size)
s.send(package)
b = s.send(message)
print("Sent " + str(b) + " bytes")
s.close()
import sock352
sock352.init(38911, 38912)
socket = sock352.socket()
# Client will drop 20% of the packets it sends.
socket.dropPercentage = 0
# Create really long string.
s = "".join([str(i) for i in range(100000)])
# for i in range(100000):
# s += str(i)
print len(s)
print "Connecting..."
socket.connect(('ilab.cs.rutgers.edu', 1010))
print "Connected"
print "Sending TEST"
socket.send(s)
ret = socket.recv(488890)
print "DATA RECEIVED BACK"
print "VALID: " + str(ret == s)
socket.close()
print "Closed socket."
