def accept_incoming(sock, RSA_PUBLIC_KEY, max_nr_of_clients):
#general recv
recv = sock.recvfrom(BUFFER_SIZE)
SENDER_ADDRESS = recv[1]
# 1.establishes the connection
if SENDER_ADDRESS not in get_connected_senders():
#if nr of connected clients is not max
if len(get_connected_senders()) < max_nr_of_clients:
#establish connection
connection_result = establish_connection(sock, RSA_PUBLIC_KEY,
recv)
#broadcast to all that somebody connected
client_conn = {
'SENDER_ADDRESS': connection_result['SENDER_ADDRESS'],
'type': 'client_conn'
}
client_conn = json_bytes_dumps(client_conn)
broadcast(sock, client_conn)
#add sender to array
add_senders_to_array(connection_result['SENDER_ADDRESS'])
return connection_result
#if nr of connected clients is max
else:
print(x * 15 + "MAXIMUM LIMIT")
max_limit = {'type': 'max limit'}
max_limit = json_bytes_dumps(max_limit)
sock.sendto(max_limit, SENDER_ADDRESS)
return 'nothing'
# 2.if already connected send recv from buffer to recv_and_verify method for future process
else:
return {'recv': recv}
def process_header(sender_header):
sender_header = Header(sender_header['SYN'], sender_header['ACK'])
sender_header.change_SYN_with_ACK()
sender_header.increment_ACK()
sender_header = sender_header.get_header_data()
sender_header = json_bytes_dumps(sender_header)
return sender_header
def process_header(receiver_header, RSA_PUBLIC_KEY):
# receiver_header = json_bytes_loads(receiver_header)
#header class
receiver_header = Header(receiver_header['SYN'], RECEIVER_ACK)
receiver_header.change_SYN_with_ACK()
receiver_header.increment_ACK()
receiver_header.add_rsa_public_key(RSA_PUBLIC_KEY)
receiver_header = receiver_header.get_header_data()
receiver_header = json_bytes_dumps(receiver_header)
return receiver_header
def recv_from_sender_and_verify(sock, RSA_PRIVATE_KEY, recv_object):
#recv from sender
recv = receive_from_sender(sock, RSA_PRIVATE_KEY, recv_object)
if 'msg' in recv:
#verify the cheksum
#if chksm not valid retransmit
verification = verify_chksm(sock, recv['msg'], recv['chksm'],
recv['SENDER_ADDRESS'],
recv['type_of_sending'],
recv['send_to_address'])
if verification:
#broadcast
if recv['type_of_sending'] == 'broadcast':
valid_msg = recv['msg']
valid_json = {
'msg': valid_msg,
'type': 'msg',
'sender': recv['SENDER_ADDRESS']
}
valid_json = json_bytes_dumps(valid_json)
broadcast(sock, valid_json)
#send to specific client
elif recv['type_of_sending'] == 'send':
ADDRESS = recv['send_to_address'][0]
PORT = recv['send_to_address'][1]
SEND_TO_ADDRESS = (ADDRESS, PORT)
if SEND_TO_ADDRESS in get_connected_senders():
valid_msg = recv['msg']
valid_json = {
'msg': valid_msg,
'type': 'msg',
'sender': recv['SENDER_ADDRESS']
}
valid_json = json_bytes_dumps(valid_json)
sock.sendto(valid_json, SEND_TO_ADDRESS)
#if in send method the port was invalid
else:
valid_json = {'type': 'invalid port'}
valid_json = json_bytes_dumps(valid_json)
print("Such address does not exist!")
sock.sendto(valid_json, recv['SENDER_ADDRESS'])
def create_json(msg_from_sender, type_of_sending, send_to_address):
encoded_msg_from_sender = str.encode(msg_from_sender)
#checksum
chksm = hashlib.sha1(encoded_msg_from_sender).hexdigest()
#return dict with msg, checksum and type that cand be msg_checksum either fin(terminate connection)
#encrypt json
json_to_send = encrypt_json(msg_from_sender, chksm, 'msg_checksum',
RSA_PUBLIC_KEY, AES_KEY, type_of_sending,
send_to_address)
#convert json el from bytes to str
json_to_send = convert_json_el_to_str(json_to_send)
#convert to json and bytes
json_to_send = json_bytes_dumps(json_to_send)
return json_to_send
def terminate_receiver_connection(sock):
while True:
#send a json with type fin
t_sender_header = Header(T_SENDER_SYN, None)
t_sender_header = t_sender_header.get_header_data()
t_sender_header['type'] = 'fin'
t_sender_header = json_bytes_dumps(t_sender_header)
sock.sendto(t_sender_header, RECEIVER_ADDRESS)
#receive and updated ACK
t_recv = sock.recvfrom(BUFFER_SIZE)[0]
t_recv = json_bytes_loads(t_recv)
if t_recv['ACK'] == T_SENDER_SYN + 1:
t_sender_header = Header(t_recv['SYN'], t_recv['ACK'])
t_sender_header.change_SYN_with_ACK()
t_sender_header.increment_ACK()
t_sender_header = t_sender_header.get_header_data()
t_sender_header = json_bytes_dumps(t_sender_header)
sock.sendto(t_sender_header, RECEIVER_ADDRESS)
print(x * 10 + "Connection terminated")
break
else:
print(x * 10 + "Error during canceling connection.")
def verify_chksm(sock, MSG_FROM_SENDER, chksm, SENDER_ADDRESS, type_of_sending,
send_to_address):
global i
#error msg-s depending on type
if type_of_sending == 'broadcast':
ERROR_MSG = json_bytes_dumps({
'msg': MSG_FROM_SENDER,
'type': 'invalid_msg',
'type_of_sending': type_of_sending
})
elif type_of_sending == 'send':
ERROR_MSG = json_bytes_dumps({
'msg': MSG_FROM_SENDER,
'type': 'invalid_msg',
'type_of_sending': type_of_sending,
'send_to_address': send_to_address
})
#hash msg and verify if it's equal with checksum
hashed_msg = str.encode(MSG_FROM_SENDER)
i = i + 1
if i > 5:
hashed_msg = hashlib.sha1(hashed_msg).hexdigest()
else:
hashed_msg = hashlib.sha1(b'hashed_msg').hexdigest()
if chksm != hashed_msg:
#if not valid send to sender error msg
sock.sendto(ERROR_MSG, SENDER_ADDRESS)
print("Invalid Message, waiting for retransmission.")
return False
else:
#if valid return true
print("Valid Message")
print("Message from {}: ".format(SENDER_ADDRESS), MSG_FROM_SENDER)
return True
def terminate_receiver_connection(sock, t_recv, SENDER_ADDRESS):
while True:
#receives SYN from sender and send updated ACK to sender for it to stop
t_send_header = Header(t_recv['SYN'], T_RECEIVER_SYN)
t_send_header.change_SYN_with_ACK()
t_send_header.increment_ACK()
t_send_header = t_send_header.get_header_data()
t_send_header = json_bytes_dumps(t_send_header)
sock.sendto(t_send_header, SENDER_ADDRESS)
t_recv = sock.recvfrom(BUFFER_SIZE)[0]
t_recv = json_bytes_loads(t_recv)
if t_recv['ACK'] == T_RECEIVER_SYN + 1:
print(x * 10 + "Connection terminated")
return True
else:
print(x * 10 + "Error during stopping connection.")
return False
def get_connected_clients(sock):
get_clients_json = {'type': 'get clients'}
get_clients_json = json_bytes_dumps(get_clients_json)
sock.sendto(get_clients_json, RECEIVER_ADDRESS)
def terminate_sender_connection(sock):
t_sender_conn = {'type': 'fin sender'}
t_sender_conn = json_bytes_dumps(t_sender_conn)
sock.sendto(t_sender_conn, RECEIVER_ADDRESS)
def receive_from_sender(sock, RSA_PRIVATE_KEY, recv_object):
#retrieve from parameters recv
recv_from_sender = recv_object
SENDER_ADDRESS = recv_from_sender[1]
json_from_sender = recv_from_sender[0]
json_from_sender = json_bytes_loads(json_from_sender)
#if type is msg_checksum then receiver receives a dict with msg,chksm,address
if json_from_sender['type'] == 'msg_checksum':
#convert json el from str to byte
json_from_sender = convert_json_el_to_byte(json_from_sender)
#decrypt json
json_from_sender = decrypt_json(json_from_sender, RSA_PRIVATE_KEY)
msg = json_from_sender["msg"]
chksm = json_from_sender['chksm']
type_of_sending = json_from_sender['type_of_sending']
send_to_address = json_from_sender['send_to_address']
return {
'msg': msg,
'chksm': chksm,
'SENDER_ADDRESS': SENDER_ADDRESS,
'type_of_sending': type_of_sending,
'send_to_address': send_to_address
}
#get connected clients method
elif json_from_sender['type'] == 'get clients':
conn_clients = {
'clients': get_connected_senders(),
'type': 'get clients'
}
conn_clients = json_bytes_dumps(conn_clients)
sock.sendto(conn_clients, SENDER_ADDRESS)
#if type is fin then receiver acknowledges that it's terminate command(server terminates)
elif json_from_sender['type'] == 'fin':
#all the ACK SYN process
termination = terminate_receiver_connection(sock, json_from_sender,
SENDER_ADDRESS)
if termination:
# if true make a copy of array and delete all connection from it
senders = get_connected_senders()
#broadcast to all that server is closed and they need to disconnect
server_disc = {'type': 'server_disc'}
server_disc = json_bytes_dumps(server_disc)
#broadcast to all
broadcast(sock, server_disc)
senders_array_copy = []
for sender in senders:
senders_array_copy.append(sender)
for sender in senders_array_copy:
terminate_sender_connection(sender)
os._exit(0)
# sender terminates connection
elif json_from_sender['type'] == 'fin sender':
termination = terminate_sender_connection(SENDER_ADDRESS)
print("CONNECTED CLIENTS: ", get_connected_senders())
if termination:
client_disc = {
'SENDER_ADDRESS': SENDER_ADDRESS,
'type': 'client_disc'
}
client_disc = json_bytes_dumps(client_disc)
broadcast(sock, client_disc)
def initial_SYN():
sender_header = Header(SENDER_SYN, None).get_header_data()
sender_header = json_bytes_dumps(sender_header)
return sender_header