def __init__(self, raw_socket): self._logger = util.get_class_logger(self) self._tls_socket = ssl.wrap_socket(raw_socket) # Print cipher in use. Handshake is done on wrap_socket call. self._logger.info("Cipher: %s", self._tls_socket.cipher())
def __init__(self, request, options): """Constructs an instance. Args: request: mod_python request. """ StreamBase.__init__(self, request) self._logger = util.get_class_logger(self) self._options = options if self._options.deflate: self._logger.debug('Deflated stream') self._request = util.DeflateRequest(self._request) self._request.client_terminated = False self._request.server_terminated = False # Holds body of received fragments. self._received_fragments = [] # Holds the opcode of the first fragment. self._original_opcode = None self._writer = FragmentedTextFrameBuilder(self._options.mask_send) self._ping_queue = deque()
def __init__(self, request, options): """Constructs an instance. Args: request: mod_python request. """ self._logger = util.get_class_logger(self) self._options = options self._request = request self._request.client_terminated = False self._request.server_terminated = False # Holds body of received fragments. self._received_fragments = [] # Holds the opcode of the first fragment. self._original_opcode = None self._writer = FragmentedFrameBuilder( self._options.mask_send, self._options.outgoing_frame_filters, self._options.encode_text_message_to_utf8) self._ping_queue = deque()
def __init__(self, request, dispatcher, allowDraft75=False, strict=False): """Construct an instance. Args: request: mod_python request. dispatcher: Dispatcher (dispatch.Dispatcher). allowDraft75: allow draft 75 handshake protocol. strict: Strictly check handshake request in draft 75. Default: False. If True, request.connection must provide get_memorized_lines method. Handshaker will add attributes such as ws_resource in performing handshake. """ self._logger = util.get_class_logger(self) self._request = request self._dispatcher = dispatcher self._strict = strict self._hybi07Handshaker = hybi06.Handshaker(request, dispatcher) self._hybi00Handshaker = hybi00.Handshaker(request, dispatcher) self._hixie75Handshaker = None if allowDraft75: self._hixie75Handshaker = draft75.Handshaker( request, dispatcher, strict)
def __init__(self, socket, options): super(ClientHandshakeProcessor, self).__init__() self._socket = socket self._options = options self._logger = util.get_class_logger(self)
def __init__(self, options): """Override SocketServer.TCPServer.__init__ to set SSL enabled socket object to self.socket before server_bind and server_activate, if necessary. """ # Share a Dispatcher among request handlers to save time for # instantiation. Dispatcher can be shared because it is thread-safe. options.dispatcher = dispatch.Dispatcher( options.websock_handlers, options.scan_dir, options.allow_handlers_outside_root_dir ) if options.websock_handlers_map_file: _alias_handlers(options.dispatcher, options.websock_handlers_map_file) warnings = options.dispatcher.source_warnings() if warnings: for warning in warnings: logging.warning("Warning in source loading: %s" % warning) self._logger = util.get_class_logger(self) self.request_queue_size = options.request_queue_size self.__ws_is_shut_down = threading.Event() self.__ws_serving = False SocketServer.BaseServer.__init__(self, (options.server_host, options.port), WebSocketRequestHandler) # Expose the options object to allow handler objects access it. We name # it with websocket_ prefix to avoid conflict. self.websocket_server_options = options self._create_sockets() self.server_bind() self.server_activate()
def __init__(self, request): self._logger = util.get_class_logger(self) self._request = request self._response_window_bits = None self._response_no_context_takeover = False
def __init__(self, root_dir, scan_dir=None, allow_handlers_outside_root_dir=True): """Construct an instance. Args: root_dir: The directory where handler definition files are placed. scan_dir: The directory where handler definition files are searched. scan_dir must be a directory under root_dir, including root_dir itself. If scan_dir is None, root_dir is used as scan_dir. scan_dir can be useful in saving scan time when root_dir contains many subdirectories. allow_handlers_outside_root_dir: Scans handler files even if their canonical path is not under root_dir. """ self._logger = util.get_class_logger(self) self._handler_suite_map = {} self._source_warnings = [] if scan_dir is None: scan_dir = root_dir if not os.path.realpath(scan_dir).startswith( os.path.realpath(root_dir)): raise DispatchException('scan_dir:%s must be a directory under ' 'root_dir:%s.' % (scan_dir, root_dir)) self._source_handler_files_in_dir(root_dir, scan_dir, allow_handlers_outside_root_dir)
def __init__( self, root_dir, scan_dir=None, allow_handlers_outside_root_dir=True): """Construct an instance. Args: root_dir: The directory where handler definition files are placed. scan_dir: The directory where handler definition files are searched. scan_dir must be a directory under root_dir, including root_dir itself. If scan_dir is None, root_dir is used as scan_dir. scan_dir can be useful in saving scan time when root_dir contains many subdirectories. allow_handlers_outside_root_dir: Scans handler files even if their canonical path is not under root_dir. """ self._logger = util.get_class_logger(self) self._handler_suite_map = {} self._source_warnings = [] if scan_dir is None: scan_dir = root_dir if not os.path.realpath(scan_dir).startswith( os.path.realpath(root_dir)): raise DispatchException('scan_dir:%s must be a directory under ' 'root_dir:%s.' % (scan_dir, root_dir)) self._source_handler_files_in_dir( root_dir, scan_dir, allow_handlers_outside_root_dir)
def __init__(self, request, options): """Constructs an instance. Args: request: mod_python request. """ StreamBase.__init__(self, request) self._logger = util.get_class_logger(self) self._options = options if self._options.deflate_stream: self._logger.debug('Setup filter for deflate-stream') self._request = util.DeflateRequest(self._request) self._request.client_terminated = False self._request.server_terminated = False # Holds body of received fragments. self._received_fragments = [] # Holds the opcode of the first fragment. self._original_opcode = None self._writer = FragmentedFrameBuilder( self._options.mask_send, self._options.outgoing_frame_filters) self._ping_queue = deque()
def __init__(self, request, options): """Constructs an instance. Args: request: mod_python request. """ StreamBase.__init__(self, request) self._logger = util.get_class_logger(self) self._options = options self._request.client_terminated = False self._request.server_terminated = False # Holds body of received fragments. self._received_fragments = [] # Holds the opcode of the first fragment. self._original_opcode = None self._writer = FragmentedFrameBuilder( self._options.mask_send, self._options.outgoing_frame_filters, self._options.encode_text_message_to_utf8) self._ping_queue = deque()
def __init__(self, options, handshake, stream_class): self._logger = util.get_class_logger(self) self._options = options self._socket = None self._handshake = handshake self._stream_class = stream_class
def __init__(self, request): """Construct PerMessageDeflateExtensionProcessor.""" ExtensionProcessorInterface.__init__(self, request) self._logger = util.get_class_logger(self) self._preferred_client_max_window_bits = None self._client_no_context_takeover = False
def __init__(self, request): """Construct an instance. Args: request: mod_python request. """ self._logger = util.get_class_logger(self) self._request = request
def __init__(self, socket, host, port, origin=None, deflate_frame=False, use_permessage_deflate=False): super(ClientHandshakeProcessor, self).__init__() self._socket = socket self._host = host self._port = port self._origin = origin self._deflate_frame = deflate_frame self._use_permessage_deflate = use_permessage_deflate self._logger = util.get_class_logger(self)
def __init__(self, socket, options): super(ClientHandshakeProcessorHybi00, self).__init__() self._socket = socket self._options = options self._logger = util.get_class_logger(self) if self._options.deflate_frame or self._options.use_permessage_deflate: logging.critical("HyBi 00 doesn't support extensions.") sys.exit(1)
def __init__(self, socket, options): super(ClientHandshakeProcessorHybi00, self).__init__() self._socket = socket self._options = options self._logger = util.get_class_logger(self) if (self._options.deflate_frame or self._options.use_permessage_deflate): logging.critical('HyBi 00 doesn\'t support extensions.') sys.exit(1)
def __init__(self, request_handler, use_tls): """Construct an instance. Args: request_handler: A WebSocketRequestHandler instance. """ self._logger = util.get_class_logger(self) self._request_handler = request_handler self.connection = _StandaloneConnection(request_handler) self._use_tls = use_tls
def __init__(self, request, client_address, server): self._logger = util.get_class_logger(self) self._options = server.websocket_server_options # Overrides CGIHTTPServerRequestHandler.cgi_directories. self.cgi_directories = self._options.cgi_directories # Replace CGIHTTPRequestHandler.is_executable method. if self._options.is_executable_method is not None: self.is_executable = self._options.is_executable_method # This actually calls BaseRequestHandler.__init__. CGIHTTPServer.CGIHTTPRequestHandler.__init__(self, request, client_address, server)
def __init__(self, request_handler, use_tls): """ Construct an instance. Args: request_handler: A WebSocketRequestHandler instance """ self._logger = util.get_class_logger(self) self._request_handler = request_handler self.connection = _StandaloneConnection(request_handler) self._use_tls = use_tls self.headers_in = request_handler.headers
def __init__(self, request, dispatcher): """Construct an instance. Args: request: mod_python request. dispatcher: Dispatcher (dispatch.Dispatcher). Handshaker will add attributes such as ws_resource during handshake. """ self._logger = util.get_class_logger(self) self._request = request self._dispatcher = dispatcher
def __init__(self, raw_socket, tls_module, tls_version, disable_tls_compression): self._logger = util.get_class_logger(self) if tls_module == _TLS_BY_STANDARD_MODULE: if tls_version == _TLS_VERSION_SSL23: version = ssl.PROTOCOL_SSLv23 elif tls_version == _TLS_VERSION_SSL3: version = ssl.PROTOCOL_SSLv3 elif tls_version == _TLS_VERSION_TLS1: version = ssl.PROTOCOL_TLSv1 else: raise ValueError( 'Invalid --tls-version flag: %r' % tls_version) if disable_tls_compression: raise ValueError( '--disable-tls-compression is not available for ssl ' 'module') self._tls_socket = ssl.wrap_socket(raw_socket, ssl_version=version) # Print cipher in use. Handshake is done on wrap_socket call. self._logger.info("Cipher: %s", self._tls_socket.cipher()) elif tls_module == _TLS_BY_PYOPENSSL: if tls_version == _TLS_VERSION_SSL23: version = OpenSSL.SSL.SSLv23_METHOD elif tls_version == _TLS_VERSION_SSL3: version = OpenSSL.SSL.SSLv3_METHOD elif tls_version == _TLS_VERSION_TLS1: version = OpenSSL.SSL.TLSv1_METHOD else: raise ValueError( 'Invalid --tls-version flag: %r' % tls_version) context = OpenSSL.SSL.Context(version) if disable_tls_compression: # OP_NO_COMPRESSION is not defined in OpenSSL module. context.set_options(0x00020000) self._tls_socket = OpenSSL.SSL.Connection(context, raw_socket) # Client mode. self._tls_socket.set_connect_state() self._tls_socket.setblocking(True) # Do handshake now (not necessary). self._tls_socket.do_handshake() else: raise ValueError('No TLS support module is available')
def __init__(self, request, dispatcher): """Opening handshake processor for the WebSocket protocol (RFC 6455). :param request: mod_python request. :param dispatcher: Dispatcher (dispatch.Dispatcher). WsH2Handshaker will add attributes such as ws_resource during handshake. """ self._logger = util.get_class_logger(self) self._request = request self._dispatcher = dispatcher
def __init__(self, configFile): print "connection init" self.configFile = configFile self.dictionary=dict() with open(self.configFile, 'r') as f: for singleLine in f: singleLine = singleLine.replace('\n','') splitedLine = singleLine.split('=') self.dictionary[splitedLine[0]] = splitedLine[1] print self.dictionary logging.basicConfig(level=logging.getLevelName(self.dictionary.get('log_level').upper())) self._socket = None self.received = Queue() self.toSend = Queue() self._logger = util.get_class_logger(self)
def __init__(self, request, options): """Constructs an instance. Args: request: mod_python request. """ StreamBase.__init__(self, request) self._logger = util.get_class_logger(self) self._options = options if self._options.deflate_stream: self._logger.debug('Setup filter for deflate-stream') self._request = util.DeflateReque
def __init__(self, request): ExtensionProcessorInterface.__init__(self, request) self._logger = util.get_class_logger(self) self._response_window_bits = None self._response_no_context_takeover = False self._bfinal = False # Calculates # (Total outgoing bytes supplied to this filter) / # (Total bytes sent to the network after applying this filter) self._outgoing_average_ratio_calculator = _AverageRatioCalculator() # Calculates # (Total bytes received from the network) / # (Total incoming bytes obtained after applying this filter) self._incoming_average_ratio_calculator = _AverageRatioCalculator()
def __init__(self, request, draft08=True): """Construct PerMessageDeflateExtensionProcessor Args: draft08: Follow the constraints on the parameters that were not specified for permessage-compress but are specified for permessage-deflate as on draft-ietf-hybi-permessage-compression-08. """ ExtensionProcessorInterface.__init__(self, request) self._logger = util.get_class_logger(self) self._c2s_max_window_bits = None self._c2s_no_context_takeover = False self._draft08 = draft08
def __init__(self, request, draft08=True): """Construct PerMessageDeflateExtensionProcessor Args: draft08: Follow the constraints on the parameters that were not specified for permessage-compress but are specified for permessage-deflate as on draft-ietf-hybi-permessage-compression-08. """ ExtensionProcessorInterface.__init__(self, request) self._logger = util.get_class_logger(self) self._preferred_client_max_window_bits = None self._client_no_context_takeover = False self._draft08 = draft08
def __init__(self, request, enable_closing_handshake=False): """Construct an instance. Args: request: mod_python request. enable_closing_handshake: to let StreamHixie75 perform closing handshake as specified in HyBi 00, set this option to True. """ StreamBase.__init__(self, request) self._logger = util.get_class_logger(self) self._enable_closing_handshake = enable_closing_handshake self._request.client_terminated = False self._request.server_terminated = False
def __init__(self, options): options.dispatcher = _HandshakeDispatcher() self._logger = util.get_class_logger(self) self.request_queue_size = options.request_queue_size self._WebSocketServer__ws_is_shut_down = threading.Event() self._WebSocketServer__ws_serving = False SocketServer.BaseServer.__init__(self, (options.server_host, options.port), ChopWebSocketRequestHandler) # Expose the options object to allow handler objects access it. We name # it with websocket_ prefix to avoid conflict. self.websocket_server_options = options self._create_sockets() self.server_bind() self.server_activate()
def __init__(self, request, dispatcher, strict=False): """Construct an instance. Args: request: mod_python request. dispatcher: Dispatcher (dispatch.Dispatcher). strict: Strictly check handshake request. Default: False. If True, request.connection must provide get_memorized_lines method. Handshaker will add attributes such as ws_resource in performing handshake. """ self._logger = util.get_class_logger(self) self._request = request self._dispatcher = dispatcher self._strict = strict
def __init__(self, request): ExtensionProcessorInterface.__init__(self, request) self._logger = util.get_class_logger(self) self._response_window_bits = None self._response_no_context_takeover = False self._bfinal = False # Counters for statistics. # Total number of outgoing bytes supplied to this filter. self._total_outgoing_payload_bytes = 0 # Total number of bytes sent to the network after applying this filter. self._total_filtered_outgoing_payload_bytes = 0 # Total number of bytes received from the network. self._total_incoming_payload_bytes = 0 # Total number of incoming bytes obtained after applying this filter. self._total_filtered_incoming_payload_bytes = 0
def __init__(self, request): self._request = request self._logger = util.get_class_logger(self) self._c2s_max_window_bits = None self._c2s_no_context_takeover = False self._compress_outgoing = False # Counters for statistics. # Total number of outgoing bytes supplied to this filter. self._total_outgoing_payload_bytes = 0 # Total number of bytes sent to the network after applying this filter. self._total_filtered_outgoing_payload_bytes = 0 # Total number of bytes received from the network. self._total_incoming_payload_bytes = 0 # Total number of incoming bytes obtained after applying this filter. self._total_filtered_incoming_payload_bytes = 0
def __init__(self, options): """Override SocketServer.TCPServer.__init__ to set SSL enabled socket object to self.socket before server_bind and server_activate, if necessary. """ self._logger = util.get_class_logger(self) self.request_queue_size = options.request_queue_size self.__ws_is_shut_down = threading.Event() self.__ws_serving = False SocketServer.BaseServer.__init__(self, (options.server_host, options.port), WebSocketRequestHandler) # Expose the options object to allow handler objects access it. We name # it with websocket_ prefix to avoid conflict. self.websocket_server_options = options self._create_sockets() self.server_bind() self.server_activate()
def __init__(self, request, client_address, server): self._logger = util.get_class_logger(self) self._options = server.websocket_server_options # Overrides CGIHTTPServerRequestHandler.cgi_directories. self.cgi_directories = self._options.cgi_directories # Replace CGIHTTPRequestHandler.is_executable method. if self._options.is_executable_method is not None: self.is_executable = self._options.is_executable_method # OWN MODIFICATION # This actually calls BaseRequestHandler.__init__. try: CGIHTTPServer.CGIHTTPRequestHandler.__init__( self, request, client_address, server) except socket.error, e: # Broken pipe, let it pass if e.errno != 32: raise self._logger.debug("WS: Broken pipe")
def __init__(self, options): self._logger = util.get_class_logger(self) self._options = options self._options.enable_mux() self._stream = None self._socket = None self._handshake = client_for_testing.WebSocketHandshake(self._options) self._incoming_frame_filter = None self._outgoing_frame_filter = None self._is_active = False self._read_thread = None self._control_blocks_condition = threading.Condition() self._control_blocks = [] self._channel_slots = collections.deque() self._logical_channels_condition = threading.Condition() self._logical_channels = {} self._timeout = 2 self._physical_connection_close_event = None self._physical_connection_close_message = None
def __init__(self, options): self._logger = util.get_class_logger(self) self._options = options self._options.enable_mux() self._stream = None self._socket = None self._handshake = client_for_testing.WebSocketHandshake(self._options) self._incoming_frame_filter = None self._outgoing_frame_filter = None self._is_active = False self._read_thread = None self._control_blocks_condition = threading.Condition() self._control_blocks = [] self._channel_slots = collections.deque() self._logical_channels_condition = threading.Condition(); self._logical_channels = {} self._timeout = 2 self._physical_connection_close_event = None self._physical_connection_close_message = None
def __init__(self, options): """Override SocketServer.TCPServer.__init__ to set SSL enabled socket object to self.socket before server_bind and server_activate, if necessary. """ print "Starting Server..." # Share a Dispatcher among request handlers to save time for # instantiation. Dispatcher can be shared because it is thread-safe. options.dispatcher = dispatch.Dispatcher( options.websock_handlers, options.scan_dir, options.allow_handlers_outside_root_dir) if options.websock_handlers_map_file: _alias_handlers(options.dispatcher, options.websock_handlers_map_file) warnings = options.dispatcher.source_warnings() if warnings: for warning in warnings: logging.warning('Warning in source loading: %s' % warning) self._logger = util.get_class_logger(self) self.request_queue_size = options.request_queue_size self.__ws_is_shut_down = threading.Event() self.__ws_serving = False SocketServer.BaseServer.__init__(self, (options.server_host, options.port), WebSocketRequestHandler) # Expose the options object to allow handler objects access it. We name # it with websocket_ prefix to avoid conflict. self.websocket_server_options = options self._create_sockets() self.server_bind() self.server_activate()
def __init__(self, deflate_max_window_bits, deflate_no_context_takeover): self._logger = util.get_class_logger(self) self._rfc1979_deflater = util._RFC1979Deflater( deflate_max_window_bits, deflate_no_context_takeover) self._rfc1979_inflater = util._RFC1979Inflater() self._bfinal = False self._compress_outgoing_enabled = False # True if a message is fragmented and compression is ongoing. self._compress_ongoing = False # Calculates # (Total outgoing bytes supplied to this filter) / # (Total bytes sent to the network after applying this filter) self._outgoing_average_ratio_calculator = _AverageRatioCalculator() # Calculates # (Total bytes received from the network) / # (Total incoming bytes obtained after applying this filter) self._incoming_average_ratio_calculator = _AverageRatioCalculator()
def __init__(self, headers, rfile, wfile): self._logger = util.get_class_logger(self) self.headers = headers self.rfile = rfile self.wfile = wfile
def __init__(self, options): self._logger = util.get_class_logger(self) self._options = options
def __init__(self, socket): self._logger = util.get_class_logger(self) self._socket = socket self.connection = ClientConnection(socket)