def login(self, sock: socket, vertex: int):
"""
Login function from a switch to this controller
:sock: Socket from the switch connection
:vertex: Vertex_ID of the switch
"""
self.logging.info(
"Received login from: [{addr}] on port [{port}] with vertex_id [{vertex}]"
.format(addr=sock.getpeername()[0],
port=sock.getsockname()[1],
vertex=vertex))
self.logging.debug("Packet [{}]".format(
self.network_state.adjacency_packet))
self.logging.info(
"Getting info for vertex[{}] at [{}]:[{}] for login".format(
vertex,
sock.getpeername()[0],
sock.getsockname()[1]))
send_data("Controller", self.router_sock,
(f"{vertex}, " + str(self.network_state.adjacency_packet)))
data = recv_data("Controller", self.router_sock)
self.logging.info(
"Sending forwarding packet from login to vertex[{}] at [{}]:[{}]".
format(vertex,
sock.getpeername()[0],
sock.getsockname()[1]))
self.send_data(sock, data)
def process_client_msgs(self, conn: socket):
msg = Client.receive_message(conn)
print('received msg:')
print(msg)
with self.CLIENTS_LOCK:
print(self.socketTCP)
print(conn)
print(conn.getpeername())
print(self.tcp_to_nick)
nickname = self.tcp_to_nick[conn.getpeername()]
try:
if msg['type'] == 'message':
print('received message from ' + nickname + ':\n' +
msg['message'])
except KeyError:
return
def add(self, sock: socket, vertex: int, port: int, ip: str):
"""
"""
self.logging.info(
"Adding connection for vertex[{}] at [{}]:[{}] : [{}]:[{}]".
format(vertex,
sock.getpeername()[0],
sock.getsockname()[1], ip, port))
self.network_state.update_port(vertex, port, ip)
send_data("Controller", self.router_sock,
(f"{vertex}, " + str(self.network_state.adjacency_packet)))
data = recv_data("Controller", self.router_sock)
self.send_data(sock, data)
self.logging.info("Connection added")
def delete(self, sock: socket, vertex: int, port: int):
"""
"""
self.logging.info(
"Removing connection for vertex[{}] at [{}]:[{}] : Vertex[{}]:Port[{}]"
.format(vertex,
sock.getpeername()[0],
sock.getsockname()[1], vertex, port))
self.network_state.update_port(vertex, port, "0.0.0.0")
self.send_data(
self.router_sock,
(f"{vertex}, " + str(self.network_state.adjacency_packet)))
data = recv_data("Controller", self.router_sock)
self.logging.info("Connection Removed")
self.send_data(sock, data)
def proxy(data: bytes, sock: socket, from_client: bool) -> bytes:
"""
Function that handles the requests that are passed to the proxy and changes the data / header on-the-fly.
:param data: raw data e.g. "GET /index.html HTTP/1.1\r\n..."
:param sock: the socket object for this connection
:param from_client: True if traffic coming from client
:return: raw (possible changed) data
"""
try:
request_key = sock.getpeername()[1]
if from_client:
data_split = data.split(b'\r\n\r\n')
raw_head = data_split[0]
headers = parse_headers(raw_head)
request_to_response[request_key] = [None, None, None]
if b'user-agent' in headers:
request_to_response[request_key][0] = headers[b'user-agent']
if b'host' in headers:
requested = b'http://' + headers[b'host'] + raw_head.split(
b'\r\n')[0].split()[1]
request_to_response[request_key][1] = requested
if b'referer' in headers:
request_to_response[request_key][2] = headers[b'referer']
return data
else:
if not data.startswith(b'HTTP'):
return data
data_split = data.split(b'\r\n\r\n')
raw_head = data_split[0]
raw_body = b'\r\n\r\n'.join(data_split[1:])
headers = parse_headers(raw_head)
if b'content-type' not in headers:
return data
if not headers[b'content-type'].lower().startswith(b'text/html'):
return data
new_headers = retrofit_headers(headers, request_key)
raw_response_head = [raw_head.split(b'\r\n')[0]]
for name, value in new_headers.items():
raw_response_head.append(name + b': ' + value)
raw_response_head = b'\r\n'.join(raw_response_head)
return raw_response_head + b'\r\n\r\n' + raw_body
except Exception as e:
print('Unexpected Exception', e)
traceback.print_exc()
return data
def exit(self, sock: socket, vertex: int):
"""
Closes socket and exits client thread
:sock: Socket to clean up
:vertex: Vertex ID that is closing
"""
self.logging.info(
"Vertex[{vertex}] session from {addr} on port {port} closed".
format(vertex=vertex,
addr=sock.getpeername()[0],
port=sock.getsockname()[1]))
self.logging.debug("Closing socket for vertex: {}".format(vertex))
sock.close()
self.send_data(self.router_sock, "EXIT")
self.router_sock.close()
exit(0)
def handle(self, client_socket: socket):
print_process("Handle_request of ", str(client_socket.getpeername()))
self.current_client_socket = client_socket
request = client_socket.recv(1024)
print(request)
first_line: str = request.splitlines()[0].decode("ascii")
verb = self._get_http_verb(first_line).lower()
http_response = None
try:
http_response = IHttpRequest.factory(verb).get_response(request)
except PageNotFound as err:
print(err.requested_page)
redirect_to = self._routes.get_redirect(err.requested_page)
print(redirect_to)
http_response = ErrorGetHttpRequest().get_response(redirect_to)
except Exception as e:
print(e)
finally:
self._respond_to_client(http_response)
self.current_client_socket.close()
def recv_greeting(app: str, sock: socket):
"""
:app: Which application is receiving the data
:sock: Socket to receive the greeting on
:return: Boolean, True if valid greeting, false otherwise
"""
logger = logging.getLogger(app)
greeting = sock.recv(28)
if greeting.decode('utf-8') == "-- CONNECTION ESTABLISHED --":
logger.debug(
"Connection established with host [{host}] on port [{port}]".
format(host=sock.getpeername()[0], port=sock.getsockname()[1]))
print(greeting.decode("utf-8"))
return True
else:
logger.error("Error with connection, aborting.")
logger.error(greeting.decode("utf-8"))
return False
def _close_connection(self, conn: socket) -> None:
self.logger.debug("Closing connection to client {}".format(
conn.getpeername()))
conn.close()
