Merge branch 'release/0.0.3'

ja3requests/__version__.py

@@ -8,7 +8,7 @@
 __title__ = "ja3requests"
 __description__ = "An http request library that can customize ja3 fingerprints."
 __url__ = "https://github.com/lxjmaster/ja3requests"
-__version__ = "0.0.2"
+__version__ = "0.0.3"
 __author__ = "Mast Luo"
 __author_email__ = "379501669@qq.com"
 __license__ = "Apache-2.0 license"

ja3requests/base/__init__.py

@@ -5,6 +5,8 @@
 Basic module.
 """
 
-from ._sessions import BaseSession
+from ._context import BaseContext
 from ._request import BaseRequest
+from ._sessions import BaseSession
+from ._response import BaseResponse
 from ._connection import BaseHttpConnection

ja3requests/base/_connection.py

@@ -10,16 +10,18 @@ class BaseHttpConnection:
 
     def __init__(self):
 
-        self._scheme = "http"
-        self._http_version = "HTTP/1.1"
-        self._port = 80
+        self._scheme = None
+        self._host = None
+        self._port = None
         self._source_address = None
         self._destination_address = None
+        self._path = None
         self._timeout = None
         self._proxy = None
         self._proxy_username = None
         self._proxy_password = None
         self._connection = None
+        self._is_close = None
 
     @property
     def scheme(self):
@@ -30,8 +32,12 @@ def scheme(self, attr):
         self._scheme = attr
 
     @property
-    def http_version(self):
-        return self._http_version
+    def host(self):
+        return self._host
+
+    @host.setter
+    def host(self, attr):
+        self._host = attr
 
     @property
     def port(self):
@@ -57,6 +63,14 @@ def destination_address(self):
     def destination_address(self, attr):
         self._destination_address = attr
 
+    @property
+    def path(self):
+        return self._path
+
+    @path.setter
+    def path(self, attr):
+        self._path = attr
+
     @property
     def timeout(self):
         return self._timeout
@@ -96,3 +110,11 @@ def connection(self):
     @connection.setter
     def connection(self, attr):
         self._connection = attr
+
+    @property
+    def is_close(self):
+        return self._is_close
+
+    @is_close.setter
+    def is_close(self, attr):
+        self._is_close = attr

ja3requests/base/_context.py

@@ -0,0 +1,74 @@
+""""
+ja3Requests.base._context
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Basic Context
+"""
+
+
+class BaseContext:
+
+    def __init__(self):
+        self._protocol = None
+        self._version = None
+        self._start_line = None
+        self._method = None
+        self._headers = None
+        self._body = None
+        self._message = None
+
+    @property
+    def protocol(self):
+        return self._protocol
+
+    @protocol.setter
+    def protocol(self, attr):
+        self._protocol = attr
+
+    @property
+    def version(self):
+        return self._version
+
+    @version.setter
+    def version(self, attr):
+        self._version = attr
+
+    @property
+    def start_line(self):
+        return self._start_line
+
+    @start_line.setter
+    def start_line(self, attr):
+        self._start_line = attr
+
+    @property
+    def method(self):
+        return self._method
+
+    @method.setter
+    def method(self, attr):
+        self._method = attr
+
+    @property
+    def headers(self):
+        return self._headers
+
+    @headers.setter
+    def headers(self, attr):
+        self._headers = attr
+
+    @property
+    def body(self):
+        return self._body
+
+    @body.setter
+    def body(self, attr):
+        self._body = attr
+
+    @property
+    def message(self):
+        return self._message
+
+    @message.setter
+    def message(self, attr):
+        self._message = attr

ja3requests/base/_response.py

@@ -0,0 +1,66 @@
+"""
+ja3Requests.base._response
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Basic Response
+"""
+
+
+class BaseResponse:
+
+    def __init__(self):
+
+        self._raw = None
+        self._protocol_version = None
+        self._status_code = None
+        self._status_text = None
+        self._headers = None
+        self._body = None
+
+    @property
+    def raw(self):
+        return self._raw
+
+    @raw.setter
+    def raw(self, attr):
+        self._raw = attr
+
+    @property
+    def protocol_version(self):
+        return self._protocol_version
+
+    @protocol_version.setter
+    def protocol_version(self, attr):
+        self._protocol_version = attr
+
+    @property
+    def status_code(self):
+        return self._status_code
+
+    @status_code.setter
+    def status_code(self, attr):
+        self._status_code = attr
+
+    @property
+    def status_text(self):
+        return self._status_text
+
+    @status_text.setter
+    def status_text(self, attr):
+        self._status_text = attr
+
+    @property
+    def headers(self):
+        return self._headers
+
+    @headers.setter
+    def headers(self, attr):
+        self._headers = attr
+
+    @property
+    def body(self):
+        return self._body
+
+    @body.setter
+    def body(self, attr):
+        self._body = attr

ja3requests/connections.py

@@ -5,16 +5,29 @@
 This module contains HTTP connection and HTTPS connection.
 """
 
+
+from .response import HTTPResponse
+from .exceptions import InvalidHost
 from .base import BaseHttpConnection
 from .protocol.sockets import create_connection
-from .protocol.exceptions import SocketTimeout, ConnectTimeoutError
+from .protocol.exceptions import SocketTimeout, ConnectTimeoutError, ReadTimeout
+
+
+DEFAULT_HTTP_SCHEME = "http"
+DEFAULT_HTTPS_SCHEME = "https"
+
+DEFAULT_HTTP_PORT = 80
+DEFAULT_HTTPS_PORT = 443
 
 
 class HTTPConnection(BaseHttpConnection):
 
     def __init__(self):
 
         super().__init__()
+        self.scheme = DEFAULT_HTTP_SCHEME
+        self.port = DEFAULT_HTTP_PORT
+        self.is_close = False
 
     def __del__(self):
         self.close()
@@ -53,16 +66,19 @@ def _ready_connect(self, **kwargs):
         if kwargs.get("source_address", None):
             self.source_address = kwargs["source_address"]
 
-        if kwargs.get("destination_address", None):
-            self.destination_address = kwargs["destination_address"]
-
-            # Remove scheme
-            if self.destination_address.startswith("http://"):
-                self.destination_address = self.destination_address.replace("http://", "")
-
-            # Remove port
-            if ":" in self.destination_address:
-                self.destination_address = self.destination_address.split(":")[0]
+        if kwargs.get("host", None):
+            host = kwargs["host"].replace("http://", "").split("/")
+            if len(host) > 0:
+                self.host = host[0]
+                self.path = "/" + "/".join(host[1:])
+                if ":" in self.host:
+                    self.destination_address = self.host.split(":")[0]
+                    if self.port is None:
+                        self.port = self.host.split(":")[1]
+                else:
+                    self.destination_address = self.host
+            else:
+                raise InvalidHost(f"Invalid Host: {kwargs['host']!r}, can not parse destination address or path.")
 
         if kwargs.get("timeout", None):
             self.timeout = kwargs["timeout"]
@@ -81,7 +97,7 @@ def connect(
             scheme=None,
             port=None,
             source_address=None,
-            destination_address=None,
+            host=None,
             timeout=None,
             proxy=None,
             proxy_username=None,
@@ -92,7 +108,7 @@ def connect(
             scheme=scheme,
             port=port,
             source_address=source_address,
-            destination_address=destination_address,
+            host=host,
             timeout=timeout,
             proxy=proxy,
             proxy_username=proxy_username,
@@ -101,22 +117,47 @@ def connect(
         conn = self._new_conn()
         self.connection = conn
 
-    def send(self):
+    def send(self, context):
         """
         Send socket.
         :return:
         """
         self.connection.sendall(
-            "GET / HTTP/1.1\r\n\r\n".encode()
+            context.message
         )
-        response_data = b""
+
+        data = self.receive()
+        response = HTTPResponse(data)
+        response.begin()
+
+        return response
+
+        # response_data = b""
+        # #
+        # self.connection.settimeout(3)
+        # try:
+        #     while True:
+        #         data = self.connection.recv(2048)
+        #         if not data:
+        #             break
+        #         response_data += data
+        # except TimeoutError:
+        #     pass
+        #
+        # print(response_data)
+        # return response_data
+
+    def receive(self):
+
+        response_data = bytes()
         while True:
-            data = self.connection.recv(1024)
+            data = self.connection.recv(2048)
             if not data:
+                self.is_close = True
                 break
-            response_data += data
 
-        return response_data
+            response_data += data
+            yield response_data
 
     def close(self):