def __init__(self, host_tcp_port, host_address, mode):

self.mode = mode

self.locally_reserved_ports = []

self.local_udp_port = 0

self.client_ip = ""

self.client_udp_port = 0

self.client_address = (self.client_ip, self.client_udp_port)

self.host_ip = host_address

self.host_tcp_port = host_tcp_port

self.host_udp_port = 0

self.host_address = (self.host_ip, self.host_udp_port)

self.server_udp_socket = socket(AF_INET, SOCK_DGRAM)

self.server_tcp_socket = socket(AF_INET, SOCK_STREAM)

self.tcp_connection_socket = socket(AF_INET, SOCK_STREAM)

self.multipart_message_buffer = ""

self.multipart_message_handling_over = True

self.features = Features()

if mode == 'client':

self. add_multipart()

self.init_connections()

#self.udp_client_socket = socket(AF_INET, SOCK_DGRAM)

self.start_udp_communication()

if mode == 'proxy':

self.init_connections()

self.start_proxy_service()

self.client_ip = ('', 0)

def init_connections(self):

if self.mode == 'client':

self.scan_available_port_and_bind(type='udpserver')

# udp client has no neet to bind

# self.scan_available_port_and_bind(type='')

self.scan_available_port_and_bind(type='tcpclient')

message = self.build_handshake_message()

self.exchange_port_information()

elif self.mode == 'proxy':

self.scan_available_port_and_bind(type='tcpclient')

self.scan_available_port_and_bind(type='tcpserver')

self.scan_available_port_and_bind(type='udpserver')

def start_proxy_service(self):

self.wait_tcp_connection_and_init()

self.start_udp_proxy()

def wait_tcp_connection_and_init(self):

print("Waiting for tcp connection..")

print("Proxy supports only one client at the time")

# listen to clients, backlog argument specifies the max no. of queued conns

self.server_tcp_socket.listen(20)

while True:

try:

print('\nWaiting to receive message from client')

self.client_tcp_socket, address = self.server_tcp_socket.accept()

client_ip, client_port = address

data = self.client_tcp_socket.recv(70)

# modify self.client address so that the port is same as used by udp

clients_message_in_parts = data.decode("utf-8").split(" ")

self.client_udp_port = clients_message_in_parts[1]

self.client_address = (client_ip, int(self.client_udp_port))

print(" ".join(clients_message_in_parts))

modified_message_in_parts = clients_message_in_parts

modified_message_in_parts[1] = " " + str(self.local_udp_port) + " "

print("in parts: {}".format(modified_message_in_parts))

modified_message = " ".join(modified_message_in_parts).encode('utf-8')

modified_message_as_bytes = bytes("".join(modified_message_in_parts).encode('utf-8'))

print("clients udp port: {}".format(self.client_udp_port))

if data:

print("\nData: {}.".format(data))

print("Client type: {}".format(type(self.client_tcp_socket)))

print("Client address: {}".format(self.client_ip))

try:

print("\nHost address: {}:{}".format(self.host_ip, self.host_tcp_port))

self.tcp_connection_socket.sendto(modified_message_as_bytes, (self.host_ip, self.host_tcp_port))

print("sent: {}\nto: {}".format(modified_message_as_bytes, (self.host_ip, self.host_tcp_port)))

server_response = self.tcp_connection_socket.recv(1024)

print(server_response)

except Exception as e:

print(str(e))

#print('sent %s bytes back to %s' % (data, address))

hosts_response_in_parts = server_response.decode("utf-8").split(" ")

print("host_response_in_parts: {}".format(server_response))

print("self.host_udp_port = hosts_response_in_parts[1]")

print("self.host_udp_port = {}".format(hosts_response_in_parts[1]))

self.host_udp_port = int(hosts_response_in_parts[1].strip('\x00'))

# save hosts upd address as a tuple

self.host_address = (self.host_ip, self.host_udp_port)

print("self.host_address: {}.".format(self.host_address))

print("response:")

print("".join(hosts_response_in_parts))

modified_response_in_parts = hosts_response_in_parts

modified_response_in_parts[1] = str(self.local_udp_port)

modified_response_as_bytes = bytes(" ".join(modified_response_in_parts).encode('utf-8'))

self.client_tcp_socket.send(modified_response_as_bytes)

self.client_tcp_socket.close()

except ValueError as e:

print(str(e))

if (server_response == b'Invalid command.\r\n'):

print("Invalid command.")

else:

break

def start_udp_proxy(self):

EOM = False

while not EOM:

print("Listening udp traffic to forward..\n")

try:

msg_received, sender_address = self.server_udp_socket.recvfrom(70)

print("Message received")

print("from: {}".format(sender_address))

self.pretty_print_packed_msg(msg_received)

print("client: {}".format(self.client_address))

print("host: {}".format(self.host_address))

print(sender_address == self.host_address or sender_address == gethostbyname(self.host_ip))

if sender_address == self.client_address:

self.server_udp_socket.sendto(msg_received, self.host_address)

print("sent to: {}.\n".format(self.host_address))

elif sender_address == self.host_address or sender_address == (str(gethostbyname(self.host_ip)),self.host_udp_port):

EOM = struct.unpack('!??HH64s', msg_received)[0]

self.server_udp_socket.sendto(msg_received, self.client_address)

print("sent to: {}.".format(self.client_address))

except Exception as e:

print(str(e))

print("Last message forwarded. Closing proxy.")

def start_udp_communication(self):

"""

starts udp transaction for exchanging questions/answers

:return: none

"""

opening_statement = "Ekki-ekki-ekki-ekki-PTANG.".encode('utf-8')

packed_statement = struct.pack('!??HH64s', True, True, len(opening_statement), 0, opening_statement)

self.send_udp_message_to_host(packed_statement)

print("sent: {}".format(opening_statement))

# listen and response

EOM = False

while not EOM:

print('listening..')

if EOM:

break

try:

msg_received, addr = self.server_udp_socket.recvfrom(70)

unpacked_msg = struct.unpack('!??HH64s', msg_received)

print("\nReceived:")

self.pretty_print_packed_msg(msg_received)

EOM = unpacked_msg[0]

ACK = unpacked_msg[1]

content_length = unpacked_msg[2]

remaining_content = unpacked_msg[3]

# print("need to handle multipart messags: {}".format(remaining_content > 0))

# print("need to handle remaining content: {}".format(not self.multipart_message_handling_over))

question = str(unpacked_msg[4].decode('utf-8'))

if remaining_content > 0:

print("remaining content was larger than 0. So we have to handle multipart messages")

self.multipart_message_handling_over = False

if not self.multipart_message_handling_over:

print("multipart handling is not over")

complete_question = self.handle_multipart_message(question, content_length, remaining_content)

print("complete question: {}".format(complete_question))

if complete_question:

self.answer_to_question(complete_question, EOM)

elif self.multipart_message_buffer == "":

self.answer_to_question(question, EOM)

except KeyboardInterrupt as KI:

print(msg_received)

if (input('Q?') == 'y'):

sys.exit(1)

except Exception as e:

print("ex. "+str(e))

def answer_to_question(self, question, EOM):

answer_to_question = answer(question)

# tell the user what's happening

print("----------------------------------------")

print("Question received: {}".format(question))

print("Answer: {}".format(answer_to_question))

if len(answer_to_question) > 64:

print("handle sending of a multipart message")

first_part_of_the_answer = answer_to_question[:64].encode('utf-8')

second_part_of_the_answer = answer_to_question[64:].encode('utf-8')

print(first_part_of_the_answer)

print(second_part_of_the_answer)

first_answer_packed = struct.pack('!??HH64s', EOM, True, len(first_part_of_the_answer), len(second_part_of_the_answer), first_part_of_the_answer)

second_answer_packed = struct.pack('!??HH64s', EOM, True, len(second_part_of_the_answer), 0, second_part_of_the_answer)

self.send_udp_message_to_host(first_answer_packed)

print("Sent: ")

self.pretty_print_packed_msg(first_answer_packed)

self.send_udp_message_to_host(second_answer_packed)

print("Sent: ")

self.pretty_print_packed_msg(second_answer_packed)

else:

byte_answer = answer_to_question.encode('utf-8')

packed_answer = struct.pack('!??HH64s', EOM, True, len(byte_answer), 0, byte_answer)

print("Sent:")

self.pretty_print_packed_msg(packed_answer)

self.send_udp_message_to_host(packed_answer)

def scan_available_port_and_bind(self, type):

"""

:param socket: socket to bind

:param host: host to bind the socket

:param type: what mode to bind the socket

:return: port

"""

for port in range(100):

port_to_try = 10000 + port

try:

if type == 'udpserver':

print("Bind {} to port {}:{}".format(self.server_udp_socket, gethostname(), port_to_try))

self.server_udp_socket.bind(('', port_to_try))

self.server_udp_socket.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)

self.local_udp_port = port_to_try

if port_to_try in self.locally_reserved_ports:

port_to_try += 1

print('udp server binded')

elif type == 'tcpserver':

print("Bind {} to port {}:{}".format(self.server_tcp_socket, gethostname(), port_to_try))

self.server_tcp_socket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)

self.server_tcp_socket.bind(('', port_to_try))

if port_to_try in self.locally_reserved_ports:

port_to_try += 1

self.host_tcp_port = port_to_try

print('tcp server binded')

elif type == 'tcpclient':

self.tcp_connection_socket.connect((self.host_ip, self.host_tcp_port))

print("Bind {} to port {}:{}".format(self.tcp_connection_socket, self.host_ip, self.host_tcp_port))

self.host_tcp_port = port_to_try

print('tcpclient init here')

available_port = port_to_try

return available_port

break

except Exception as e:

print(str(e))

def build_handshake_message(self):

# builds the init message which is sent with tcp to negotiate extra features

#:return: built message in bytes encoded to 'utf-8'

features = ('{} {} {} {}'.format(self.features.get_multipart_status()[1],

self.features.get_confidentiality_status()[1],

self.features.get_integrity_status()[1],

self.features.get_availability_status()[1]))

features = features.replace('None', '').strip(" ")

print("features: '{}'".format(features))

message = 'HELO {} {}'.format(self.local_udp_port, features)

if message.endswith(' '):

message.rstrip(' ')

message += "\r\n"

print(message)

return bytes(message.encode('utf-8'))

def exchange_port_information(self):

"""

TODO: ADD EXTRA FEATURES

Get hosts port for udp-connection

"""

# craft the message and send it

self.send_tcp_message(self.build_handshake_message())

# receive answer and parse port from it

received = self.tcp_connection_socket.recv(1024)

try:

self.host_udp_port = int(received.decode('utf-8').split(' ')[1].split('\r')[0])

except ValueError as VE:

print('uusiksi portin parse')

# tell the user what's happening

print("Received msg: {}.".format(received))

print("Host listens on port: {}.".format(self.host_udp_port))

print("Clients UDP port: {} has been sent.\n\

Closing TCP-socket..".format(self.local_udp_port))

self.host_address = self.host_ip, self.host_udp_port

# close connection

self.tcp_connection_socket.close()

def send_tcp_message(self, message):

if type(message) != bytes:

message = message.encode('utf-8')

try:

self.tcp_connection_socket.send(message)

print(message)

print("send_tcp_messag: {}.".format(self.tcp_connection_socket.getsockname()))

except IOError as e:

if e.errno == errno.EPIPE:

self.tcp_connection_socket.connect((self.host_ip, self.host_tcp_port))

print('message sent')

def send_udp_message_to_host(self, message):

"""

:param message: message to sent

:param sock: UDP socket to use

"""

self.server_udp_socket.sendto(message, (self.host_ip, self.host_udp_port))

self.pretty_print_packed_msg(message)

print("Sent to {} from {}".format(self.host_address, self.server_udp_socket.getsockname()))

def add_multipart(self):

if input('Add multipart feature? [y/n]: ') == 'y':

self.features.set_multipart_status(True)

def handle_multipart_message(self, message, content_length, remaining_content):

print("\nhandling multipart message:")

self.multipart_message_buffer = self.multipart_message_buffer + message

print("\t\tbuffer: {}.".format(self.multipart_message_buffer))

print("\t\tbuffer length: {}.".format(len(self.multipart_message_buffer)))

self.multipart_message_handling_over = False

# print("message: {}.".format(message))

# print("content length: {}".format(content_length))

# print("remaining content: {}".format(remaining_content))

# print("length of buffer: {}".format(len(self.multipart_message_buffer)))

if remaining_content == 0:

complete_multipart_message = self.multipart_message_buffer

self.multipart_message_buffer = ""

self.multipart_message_handling_over = True

print("multipart message compeleted: {}".format(complete_multipart_message))

return complete_multipart_message

def handle_remaining_multipart_content(self, msg):

print("\nHandling remaining content")

print("Buffer: {}".format(self.question_buffer))

print("Partial question: {}".format(msg))

question_to_return = self.question_buffer[0] + msg

self.question_buffer[0] = None

print("remaining content parsed together: {}".format(question_to_return))

print("question buffer after handling remaining content\n{}.".format(self.question_buffer))

return question_to_return

def data_remaining(self, data_remaining):

if data_remaining > 0:

return True

else:

return False

def pretty_print_packed_msg(self,msg):

unpacked = struct.unpack('!??HH64s', msg)

print("\nMessage unpacked:")

print("\t\tEOM:\t\t\t{}".format(unpacked[0]))

print("\t\tACK:\t\t\t{}".format(unpacked[1]))

print("\t\tContent length:\t\t{}".format(unpacked[2]))

print("\t\tRemaining content:\t{}".format(unpacked[3]))

print("\t\tContent:\t\t{}\n".format(unpacked[4].decode('utf-8').strip("\x00")))