def server_handshake(self):
is_handshake_successful = False
while not is_handshake_successful:
self.get_header()
self.get_payload_eop()
self.quantity_packages_to_receive = self.package_header[3]
print(f'header recebido: {self.r_header}')
if self.package_header[2] == SERVER_ID:
print(f'Recebido HS do client - ID correto\n')
if self.package_header[0] == 1:
payload = []
header_list = [0 for i in range(10)]
header_list[0] = 2 # mensagem to tipo 2 - server ocioso
header_list[1] = CLIENT_ID
header_list[2] = SERVER_ID
datagram_obj = Datagram(payload, header_list)
self.package = datagram_obj.get_datagram()
self.send_package()
is_handshake_successful = True
print(f'enviado resposta para o client')
else:
print(f'ID do servidor não confere, ignorando mensagem...')
def server_close_session(self, session):
print("Before closing session:", self.gainer.sessions)
dtg = Datagram(TransportAim.CLOSE, self.gainer.ip, self.gainer.port,
session['client_ip'], session['client_port'])
app_layer_resp = {'verb': AppVerb.CLOSE, 'message': "Session closed."}
dtg.set_payload(app_layer_resp)
self.send_datagram(dtg)
del self.gainer.sessions[session['client_ip']]
print("After closing session:", self.gainer.sessions)
def create_shut_down_signal(self):
payload = []
self.header_list = [1 for i in range(10)]
self.header_list[0] = 5 # mensagem to tipo 1 - handshake
self.header_list[1] = CLIENT_ID
self.header_list[2] = SERVER_ID
datagram_obj = Datagram(payload, self.header_list)
self.package = datagram_obj.get_datagram()
def receive_full_packages(self):
self.n_last_package_received = 0
while self.n_current_package < self.quantity_packages_to_receive:
self.timer1 = time.time()
self.timer2 = self.timer1
while self.com2.rx.getBufferLen() == 0:
current_time = time.time()
elapsed_timer1 = current_time - self.timer1
elapsed_timer2 = current_time - self.timer2
if elapsed_timer1 >= 20:
print(
f'Tempo máximo excedido, avisando client desligamento...'
)
payload = []
header_list = [1 for i in range(10)]
header_list[0] = 5
header_list[1] = CLIENT_ID
header_list[2] = SERVER_ID
datagram_obj = Datagram(payload, header_list)
self.package = datagram_obj.get_datagram()
self.send_package()
self.shutdown()
if elapsed_timer2 >= 5:
print(
f'5 segundos sem receber o proximo pacote, enviando resposta novamente...'
)
self.send_package()
self.timer2 = time.time()
self.get_header()
self.get_payload_eop()
# verify eop and current == last + 1
# verificar se o pacote atual é igual ao anterior + 1
self.is_next_package = self.n_last_package_received + 1 == self.n_current_package
self.is_eop_right = self.r_eop == b'\xff\xaa\xff\xaa'
print(f'Recebeu o proximo? [{self.is_next_package}]', end=' | ')
print(f'Is eop ok? [{self.is_eop_right}]', end=" | ")
print(
f'Received package [{self.n_current_package} / {self.quantity_packages_to_receive}]'
)
self.build_response()
self.send_package()
print(f'Received all packages')
self.juntar_imagem()
def client_close_session(self, app_layer_req):
server_ip = app_layer_req['data']['server_ip']
dtg = Datagram(TransportAim.CLOSE, self.gainer.ip, self.gainer.port,
self.gainer.sessions[server_ip]['server_ip'],
self.gainer.sessions[server_ip]['server_port'])
dtg.set_payload(app_layer_req)
self.send_datagram(dtg)
dtg, address = self.gainer.transport.receive_datagram()
print(dtg.aim)
print(self.gainer.sessions)
del self.gainer.sessions[server_ip]
print(self.gainer.sessions)
def client_handshake(self):
handshake_successful = False
payload = []
self.header_list = [0 for i in range(10)]
self.header_list[0] = 1 # mensagem to tipo 1 - handshake
self.header_list[1] = CLIENT_ID
self.header_list[2] = SERVER_ID
self.header_list[3] = len(self.l_packages)
self.header_list[5] = FILE_ID
datagram_obj = Datagram(payload, self.header_list)
datagram = datagram_obj.get_datagram()
self.package = datagram
print(f'Enviando handshake para o Servidor..')
self.send_package()
self.start_time1 = time.time()
self.start_time2 = time.time()
while not handshake_successful:
while self.com1.rx.getBufferLen() == 0:
self.time_delta1 = time.time() - self.start_time1
self.time_delta2 = time.time() - self.start_time2
if self.time_delta2 > 20:
print(
f'Tempo máximo excedido, avisando server desligamento...'
)
self.create_shut_down_signal()
self.send_package()
time.sleep(1)
self.shutdown()
elif self.time_delta1 >= 5:
should_send_again = input(
'Didn\'t receive response. Send again? (s/n) ')
if should_send_again == 's':
print(f'Enviando novamente...\n')
self.send_package()
self.start_time1 = time.time()
else:
self.shutdown()
self.get_header()
self.get_payload_eop()
if self.package_header[0] == 2:
handshake_successful = True
print(f'Server está ocioso... começando o envio\n')
else:
print(f'Não teve sucesso no handshake...')
def receive(self, bus_handler):
'''@summary: Read the data from Bus.
Create a datagram.
@param bus_handler: Handler to Bus to read data from.
@type bus_handler: integer
@return: An object with the obtained data. Null-able.
@rtype: Datagram
'''
ph_files = POINTER(c_int)()
pp_metadata = (c_char_p)()
pp_params = (c_char_p)()
pn_files = (c_int)()
pn_metadata = (c_int)()
pn_params = (c_int)()
# Invoke C function
n_status = self.bus_back_.bus_recv_msg(bus_handler,
ph_files,
pn_files,
pp_metadata,
pn_metadata,
pp_params,
pn_params)
result_dtg = None
if 0 <= n_status:
# The invocation was successful.
# De-serialize the data
# Aggregate file descriptors
n_files = pn_files.value
h_files = []
for i in range(n_files):
h_files.append(ph_files[i])
# Extract Python strings
n_metadata = pn_metadata.value
str_metadata = pp_metadata.value
n_params = pn_params.value
str_params = pp_params.value
# Trim the junk out
if 0 < n_metadata:
str_metadata = str_metadata[0:n_metadata]
str_params = str_params[0:n_params]
# Construct actual result datagram
result_dtg = Datagram()
result_dtg.from_raw_data(h_files,
str_metadata,
str_params)
return result_dtg
def receive(self, sbus_handler):
'''@summary: Read the data from SBus.
Create a datagram.
@param sbus_handler: Handler to SBus to read data from.
@type sbus_handler: integer
@return: An object with the obtained data. Null-able.
@rtype: SBusDatagram
'''
ph_files = POINTER(c_int)()
pp_metadata = (c_char_p)()
pp_params = (c_char_p)()
pn_files = (c_int)()
pn_metadata = (c_int)()
pn_params = (c_int)()
# Invoke C function
n_status = self.sbus_back_.sbus_recv_msg(sbus_handler,
ph_files,
pn_files,
pp_metadata,
pn_metadata,
pp_params,
pn_params)
result_dtg = None
if 0 <= n_status:
# The invocation was successful.
# De-serialize the data
# Aggregate file descriptors
n_files = pn_files.value
h_files = []
for i in range(n_files):
h_files.append(ph_files[i])
# Extract Python strings
n_metadata = pn_metadata.value
str_metadata = pp_metadata.value
n_params = pn_params.value
str_params = pp_params.value
# Trim the junk out
if 0 < n_metadata:
str_metadata = str_metadata[0:n_metadata]
str_params = str_params[0:n_params]
# Construct actual result datagram
result_dtg = Datagram()
result_dtg.from_raw_data(h_files,
str_metadata,
str_params)
return result_dtg
def delete_user(self, data, session):
dtg = Datagram(TransportAim.APP_RESPONSE, self.gainer.ip,
self.gainer.port, session['client_ip'],
session['client_port'])
if data['username'] not in self.gainer.users.keys():
app_layer_resp = {
'verb': AppVerb.ERR,
'message': "This user doe not exists in the database."
}
else:
del self.gainer.users[data['username']]
app_layer_resp = {'verb': AppVerb.OK, 'message': "User deleted."}
dtg.set_payload(app_layer_resp)
self.gainer.transport.send_datagram(dtg)
def client_send_data(self, app_layer_req, dest_ip):
if dest_ip not in self.gainer.sessions.keys():
session = self.gainer.transport.get_session(dest_ip)
if not session:
raise Exception(
"Could not get a session after several attempts.")
session = self.gainer.sessions[dest_ip]
print("===========================================================")
dtg = Datagram(TransportAim.APP_REQUEST, self.gainer.ip,
self.gainer.port, session['server_ip'],
config.SERVER_PORT)
dtg.set_payload(app_layer_req)
self.gainer.transport.send_datagram(dtg)
recv_dtg, address = self.gainer.transport.receive_datagram()
print("App response:", recv_dtg.get_payload())
def send_packet(self, payload, num_payloads, payload_index):
packet = Datagram()
packet.set_head(message_type=1,
message_id=1,
num_payloads=num_payloads,
payload_index=payload_index,
payload_size=len(payload),
error_type=0,
restart_index=0)
packet.set_payload(payload=payload)
packet.set_EOP(0)
self.transmitter.send(packet.get_datagram())
def build_packages(self):
self.header_list = [1 for i in range(10)]
self.header_list[0] = 3 # mensagem to tipo 1 - handshake
self.header_list[1] = CLIENT_ID
self.header_list[2] = SERVER_ID
for index_package in range(len(self.l_bytes_img)):
payload = self.l_bytes_img[index_package]
self.header_list[3] = len(self.l_bytes_img)
self.header_list[4] = index_package + 1
self.header_list[5] = len(payload)
datagram = Datagram(payload, self.header_list)
self.l_packages.append(datagram.get_datagram())
self.len_packages = len(self.l_packages)
def senddatagram(self, ip_src, ip_dst, ttl, ip_proto, data):
datagram = Datagram.pack_datagram(ip_src, ip_dst, ttl, ip_proto, data)
## Here, let's set dst_mac according to our program >>>>
dst_mac = util.ip2mac(loadConfig.loadDstIP())
self.sendto(dst_mac, datagram, None)
""" how to acquire dst_mac"""
def __init__(self, data):
self.version = ord(data[0]) >> 4
self.header_len = (ord(data[0]) & 0x0F) << 2
self.size = struct.unpack(">H", data[2:4])[0]
self.flags = ord(data[6]) >> 5
self.proto = ord(data[9])
self.src = inet_ntoa(data[12:16])
self.dst = inet_ntoa(data[16:20])
self.datagram = Datagram.create(self.proto, data[self.header_len :])
def get_datagram(self, source_context):
ADDRESS = self.sources[source_context]
PORT = int(self.config.get("global", "PORT", "5005"))
if source_context not in self.datagrams:
self.logger.debug(f"building a datagram for {source_context}")
self.datagrams[source_context] = \
Datagram("Bogus", server=ADDRESS, port=PORT)
self.datagrams[source_context].ping()
return self.datagrams[source_context]
def get_datagram(self, source_context):
ADDRESS = config.host_for(self.sources[source_context])
PORT = int(self.config.get("global", "PORT", "5005"))
if source_context not in self.datagrams:
# self.logger.debug(f"building a datagram for {source_context}")
name = f"Datagram {self.context}"
self.datagrams[source_context] = \
Datagram("Bogus", server=ADDRESS, port=PORT,
name=name, compress=True)
self.datagrams[source_context].ping()
return self.datagrams[source_context]
def propose_session(self, recv_dtg):
dtg = Datagram(TransportAim.SESSION_PROPOSAL, self.gainer.ip,
self.gainer.port, recv_dtg.source_ip,
recv_dtg.source_port)
if recv_dtg.source_ip in self.gainer.sessions.keys():
session = self.gainer.sessions[recv_dtg.source_ip]
dtg.set_payload(session)
self.send_datagram(dtg)
else:
session = {
'session_id': len(self.gainer.sessions),
'server_ip': self.gainer.ip,
'server_port': self.gainer.port,
'client_ip': recv_dtg.source_ip,
'client_port': recv_dtg.source_port,
'AES_key': utils.random_string()
}
self.gainer.sessions[session['client_ip']] = session
dtg.set_payload(session)
self.send_datagram(dtg)
self.gainer.AES_ciphers[recv_dtg.source_ip] = None
cipher = AES.new(session['AES_key'].encode(), AES.MODE_ECB)
self.gainer.AES_ciphers[recv_dtg.source_ip] = cipher
def send_handshake(self):
packet = Datagram()
packet.set_head(message_type=2,
message_id=1,
num_payloads=0,
payload_index=0,
payload_size=0,
error_type=0,
restart_index=0)
packet.set_EOP()
self.transmitter.send(packet.get_datagram())
def get_session(self, dest_ip):
dtg = Datagram(TransportAim.GET_SESSION, self.gainer.ip,
self.gainer.port, dest_ip, config.SERVER_PORT)
for i in range(config.GET_SESSION_ATTEMPTS):
self.send_datagram(dtg)
recv_dtg, address = self.receive_datagram()
if recv_dtg and address:
self.gainer.sessions[
recv_dtg.source_ip] = recv_dtg.get_payload()
key = self.gainer.sessions[recv_dtg.source_ip]['AES_key']
self.gainer.AES_ciphers[recv_dtg.source_ip] = AES.new(
key.encode(), AES.MODE_ECB)
return self.gainer.sessions[recv_dtg.source_ip]
return None
def build_response(self):
is_package_ok = self.is_next_package and self.is_eop_right
payload = []
header_list = [0 for i in range(10)]
if is_package_ok: # create type4 msg representing that the package was received successfully
self.l_received_payloads.append(self.r_payload)
print(f'package [{self.n_current_package}] received correctly')
self.n_last_package_received = self.n_current_package
header_list[0] = 4 # mensagem to tipo 1 - handshake
header_list[1] = CLIENT_ID
header_list[2] = SERVER_ID
header_list[7] = self.n_last_package_received
else:
print(
f'package [{self.n_current_package}] had some error, requesting again..'
)
header_list[0] = 6 # mensagem to tipo 6 - solicitando reenvio
header_list[1] = CLIENT_ID
header_list[2] = SERVER_ID
header_list[6] = self.n_last_package_received + 1
datagram_obj = Datagram(payload, header_list)
self.package = datagram_obj.get_datagram()
def recvdatagram(self):
data = None
protocol = 0
while data == None:
if self.received == True:
datagram = self.payload
gram = Datagram.unpack_dartagram(datagram)
# print(gram.ip_dst)
if self.src_ip == inet_ntoa(gram.ip_dst):
data = gram.payload
protocol = gram.ip_proto
self.received = False
""" here need us to add a header check , check localip ==dst_ip"""
"""I think that here we need to reserve the protocol number"""
return protocol, data
def receive_datagram(self):
time.sleep(10)
print(
"====================================================================="
)
recv_dtg, address = self.gainer.sock.recvfrom(config.RECV_DATA_SIZE)
utils.write("Received dtg: ", recv_dtg)
if address[0] in self.gainer.AES_ciphers.keys():
cipher = self.gainer.AES_ciphers[address[0]]
recv_dtg = cipher.decrypt(recv_dtg)
utils.write("Decrypted recv dtg: ", recv_dtg)
recv_dtg: Datagram = pickle.loads(recv_dtg)
utils.write("Received dtg aim: ", recv_dtg.aim)
time.sleep(5)
utils.write("Sending ack", "")
if utils.valid_cksm(recv_dtg.get_payload(), recv_dtg.get_cksm()):
aim = TransportAim.OK
else:
aim = TransportAim.CORRUPTED
utils.write("Sending as ack: ", aim)
ack_dtg = Datagram(aim, self.gainer.ip, self.gainer.port,
recv_dtg.source_ip, recv_dtg.source_port)
ack_dtg = pickle.dumps(ack_dtg)
utils.write("Ack dtg encoded: ", ack_dtg)
if address[0] in self.gainer.AES_ciphers.keys():
cipher = self.gainer.AES_ciphers[address[0]]
ack_dtg = utils.append_zs(ack_dtg)
ack_dtg = cipher.encrypt(ack_dtg)
utils.write("Encrypted ack dtg: ", ack_dtg)
self.gainer.sock.sendto(ack_dtg, address)
print(
"====================================================================="
)
return recv_dtg, address
def _non_blocking_receive(self):
"""Returns raw datagram if any received."""
# Update internal state.
# TODO: Updates done only when this function is called.
# Check for delivered packets.
current_time = time.time()
while self._transmitting_heap:
delivery_time, id_, raw_datagram, packet = self._transmitting_heap[0]
if delivery_time <= current_time:
# Packet delivery time reached --- put it in delivered packets
# queue.
self._delivered_frames_queue.append(raw_datagram)
heapq.heappop(self._transmitting_heap)
self._logger.debug("Deferred packet with id={0} " \
"delivered: {1}".format(id_, str(packet)))
self.send_receive_queue.put((id_, True))
else:
break
# Check for actual received packets.
raw_datagram = \
super(ControllableFrameTransmitter, self).receive(block=False)
if raw_datagram is not None:
# Try to decode frame as packet.
try:
datagram = Datagram.deserialize(raw_datagram)
current_time = time.time()
protocol, packet = datagram_to_packet(datagram, self._src_name)
# Decoded packet --- put it on queue and emit signal about
# new packet transmission.
packet.time = current_time - packet.time
real_transmit_time = current_time - datagram.time
assert real_transmit_time >= 0
transmit_time = real_transmit_time * \
config.packets_delivery_time_factor
delivery_time = current_time + transmit_time
heap_item = ControllableFrameTransmitter._HeapItem(
delivery_time,
self._id_it.next(),
raw_datagram,
packet)
heapq.heappush(self._transmitting_heap, heap_item)
self._logger.debug(
"Start transmission of deferred packet "
"(deliver in {0} seconds) with id={1}: {2}".format(
transmit_time, heap_item.id, str(packet)))
self.send_receive_queue.put((heap_item.id,
current_time, delivery_time, protocol, packet))
except InvalidDatagramException, InvalidPacketException:
self._logger.warning(
"Received raw datagram is not packet: 0x{0}".format(
raw_datagram.encode('hex')))
self._delivered_frames_queue.append(raw_datagram)
from utils import open_image, separate_packages
from datagram import Datagram
img = open_image('imgs/advice.png')
pkgs = separate_packages(img)
for i in pkgs:
header_list = [1 for i in range(10)]
a = Datagram(payload=[], header_list=header_list).get_datagram()
print(a)
break