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()