wisp-python 0.6.1__tar.gz → 0.8.0__tar.gz

wisp_python-0.8.0/LICENSE_third_party.md

@@ -0,0 +1,296 @@
+# Third Party Licenses
+
+## websockets
+
+Link: https://github.com/python-websockets/websockets
+
+```
+Copyright (c) Aymeric Augustin and contributors
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Neither the name of the copyright holder nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+```
+
+## asyncudp
+
+Link: https://github.com/eerimoq/asyncudp
+
+```
+The MIT License (MIT)
+
+Copyright (c) 2021 Erik Moqvist
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
+## python-socks
+
+Link: https://github.com/romis2012/python-socks
+
+```
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+```
+
+## uvloop
+
+Link: https://github.com/MagicStack/uvloop
+
+```
+The MIT License
+
+Copyright (C) 2016-present the uvloop authors and contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+```

{wisp_python-0.6.1/src/wisp_python.egg-info → wisp_python-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wisp-python
-Version: 0.6.1
+Version: 0.8.0
 Summary: An implementation of a Wisp proxy server in Python
 Author: ading2210
 Project-URL: Homepage, https://github.com/MercuryWorkshop/wisp-server-python
@@ -11,8 +11,10 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
+License-File: LICENSE_third_party.md
 Requires-Dist: websockets
 Requires-Dist: asyncudp
+Requires-Dist: python-socks[asyncio]
 Requires-Dist: uvloop; sys_platform != "win32" and sys_platform != "cygwin"
 Dynamic: license-file
 
@@ -36,18 +38,14 @@ pip3 install wisp-python
 ```
 
 ## Running the Server:
-There are two different versions of the server:
-- Async (`wisp.server`) - The default, based on asyncio. It is more stable, but slower.
-- Threading (`wisp.server.threading`) - An faster alternative based on threading. It is about 40-80% faster, but possibly unstable. If you use Python's experimental [free threading](https://docs.python.org/3/howto/free-threading-python.html) builds, performance will scale linearly with your available CPU cores.
-
 For the best performance use [CPython](https://github.com/python/cpython) 3.11 or newer. [PyPy](https://github.com/pypy/pypy) is not recommended as it is a lot slower than CPython here. 
 
-To start the server, run `python3 -m wisp.server` (or `python3 -m wisp.server.threading`). The program accepts the following arguments:
+To start the server, run `python3 -m wisp.server`. The program accepts the following arguments:
 ```
 usage: wisp-server-python [-h] [--host HOST] [--port PORT] [--static STATIC] [--limits] [--bandwidth BANDWIDTH] [--connections CONNECTIONS] [--window WINDOW] [--allow-loopback] [--allow-private]
-                          [--log-level LOG_LEVEL]
+                          [--log-level LOG_LEVEL] [--threads THREADS] [--proxy PROXY]
 
-A Wisp server implementation, written in Python (v0.5.0)
+A Wisp server implementation, written in Python (v0.8.0)
 
 options:
   -h, --help            show this help message and exit
@@ -64,6 +62,8 @@ options:
   --allow-private       Allow connections to private IP addresses.
   --log-level LOG_LEVEL
                         The log level (either debug, info, warning, error, or critical).
+  --threads THREADS     The number of threads to run the server on. By default it uses all CPU cores. (Linux only)
+  --proxy PROXY         The url of the socks5h, socks5, sock4a, socks4 or http proxy to use.
 ```
 
 ## Roadmap:
@@ -76,10 +76,12 @@ options:
 ## Copyright:
 This repository is licensed under the GNU AGPL v3.
 
+A few third party libraries are used. See [`LICENSE_third_party.md`](https://github.com/MercuryWorkshop/wisp-server-python/blob/main/LICENSE).
+
 ### Copyright Notice:
 ```
 wisp-server-python: a Wisp server implementation written in Python
-Copyright (C) 2024 Mercury Workshop
+Copyright (C) 2025 Mercury Workshop
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU Affero General Public License as published by

{wisp_python-0.6.1 → wisp_python-0.8.0}/README.md

@@ -18,18 +18,14 @@ pip3 install wisp-python
 ```
 
 ## Running the Server:
-There are two different versions of the server:
-- Async (`wisp.server`) - The default, based on asyncio. It is more stable, but slower.
-- Threading (`wisp.server.threading`) - An faster alternative based on threading. It is about 40-80% faster, but possibly unstable. If you use Python's experimental [free threading](https://docs.python.org/3/howto/free-threading-python.html) builds, performance will scale linearly with your available CPU cores.
-
 For the best performance use [CPython](https://github.com/python/cpython) 3.11 or newer. [PyPy](https://github.com/pypy/pypy) is not recommended as it is a lot slower than CPython here. 
 
-To start the server, run `python3 -m wisp.server` (or `python3 -m wisp.server.threading`). The program accepts the following arguments:
+To start the server, run `python3 -m wisp.server`. The program accepts the following arguments:
 ```
 usage: wisp-server-python [-h] [--host HOST] [--port PORT] [--static STATIC] [--limits] [--bandwidth BANDWIDTH] [--connections CONNECTIONS] [--window WINDOW] [--allow-loopback] [--allow-private]
-                          [--log-level LOG_LEVEL]
+                          [--log-level LOG_LEVEL] [--threads THREADS] [--proxy PROXY]
 
-A Wisp server implementation, written in Python (v0.5.0)
+A Wisp server implementation, written in Python (v0.8.0)
 
 options:
   -h, --help            show this help message and exit
@@ -46,6 +42,8 @@ options:
   --allow-private       Allow connections to private IP addresses.
   --log-level LOG_LEVEL
                         The log level (either debug, info, warning, error, or critical).
+  --threads THREADS     The number of threads to run the server on. By default it uses all CPU cores. (Linux only)
+  --proxy PROXY         The url of the socks5h, socks5, sock4a, socks4 or http proxy to use.
 ```
 
 ## Roadmap:
@@ -58,10 +56,12 @@ options:
 ## Copyright:
 This repository is licensed under the GNU AGPL v3.
 
+A few third party libraries are used. See [`LICENSE_third_party.md`](https://github.com/MercuryWorkshop/wisp-server-python/blob/main/LICENSE).
+
 ### Copyright Notice:
 ```
 wisp-server-python: a Wisp server implementation written in Python
-Copyright (C) 2024 Mercury Workshop
+Copyright (C) 2025 Mercury Workshop
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU Affero General Public License as published by

{wisp_python-0.6.1 → wisp_python-0.8.0}/pyproject.toml

@@ -6,12 +6,12 @@ requires = ["setuptools>=61.0", "toml"]
 build-backend = "setuptools.build_meta"
 
 [tool.setuptools]
-packages = ["wisp", "wisp.server", "wisp.server.threading"]
+packages = ["wisp", "wisp.server"]
 package-dir = {"" = "src"}
 
 [project]
 name = "wisp-python"
-version = "0.6.1"
+version = "0.8.0"
 authors = [
   {name="ading2210"},
 ]
@@ -26,6 +26,7 @@ classifiers = [
 dependencies = [
   "websockets",
   "asyncudp",
+  "python-socks[asyncio]",
   "uvloop; sys_platform != 'win32' and sys_platform != 'cygwin'"
 ]
 

wisp_python-0.8.0/src/wisp/server/__main__.py

@@ -0,0 +1,4 @@
+from wisp.server import cli
+
+if __name__ == "__main__":
+  cli.main()

wisp_python-0.8.0/src/wisp/server/cli.py

@@ -0,0 +1,89 @@
+import asyncio
+import argparse
+import pathlib
+import sys
+import logging
+import multiprocessing
+
+try:
+  import uvloop
+  use_uvloop = True
+except ImportError:
+  use_uvloop = False
+
+import wisp
+from wisp.server import http 
+from wisp.server import net
+
+def run_async(func, *args, **kwargs):
+  try:
+    if use_uvloop:
+      uvloop.run(func(*args, **kwargs))
+    else:
+      #uvloop doesn't support windows at all so we don't need to print the error
+      if not sys.platform in ("win32", "cygwin"):
+        logging.error("Importing uvloop failed. Falling back to asyncio, which is slower.")
+      asyncio.run(func(*args, **kwargs))
+  except KeyboardInterrupt:
+    pass
+
+def run_http(args):
+  run_async(http.main, args)
+
+def main():
+  parser = argparse.ArgumentParser(
+    prog="wisp-server-python",
+    description=f"A Wisp server implementation, written in Python (v{wisp.version})"
+  )
+
+  parser.add_argument("--host", default="127.0.0.1", help="The hostname the server will listen on.")
+  parser.add_argument("--port", default=6001, help="The TCP port the server will listen on.")
+  parser.add_argument("--static", help="Where static files are served from.")
+  parser.add_argument("--limits", action="store_true", help="Enable rate limits.")
+  parser.add_argument("--bandwidth", default=1000, help="Bandwidth limit per IP, in kilobytes per second.")
+  parser.add_argument("--connections", default=30, help="New connections limit per IP.")
+  parser.add_argument("--window", default=60, help="Fixed window length for rate limits, in seconds.")
+  parser.add_argument("--allow-loopback", action="store_true", help="Allow connections to loopback IP addresses.")
+  parser.add_argument("--allow-private", action="store_true", help="Allow connections to private IP addresses.")
+  parser.add_argument("--log-level", default="info", help="The log level (either debug, info, warning, error, or critical).")
+  parser.add_argument("--threads", default=0, help="The number of threads to run the server on. By default it uses all CPU cores. (Linux only)")
+  parser.add_argument("--proxy", default=None, help="The url of the socks5h, socks5, sock4a, socks4 or http proxy to use.")
+  args = parser.parse_args()
+
+  logging.basicConfig(
+    format="[%(asctime)s] %(levelname)-8s %(message)s",
+    level=getattr(logging, args.log_level.upper()),
+    datefmt="%Y/%m/%d - %H:%M:%S"
+  )
+
+  logging.info(f"running wisp-server-python v{wisp.version} (async)")
+  if args.static:
+    static_path = pathlib.Path(args.static).resolve()
+    logging.info(f"serving static files from {static_path}")
+  if args.limits:
+    logging.info("enabled rate limits")
+  if args.proxy:
+    logging.info(f"proxy enabled: {args.proxy}")
+  logging.info(f"listening on {args.host}:{args.port}")
+
+  threads = int(args.threads)
+  if net.reuse_port_supported():
+    if threads == 0:
+      threads = multiprocessing.cpu_count()
+    logging.info(f"running using {threads} threads")
+
+    processes = []
+    for i in range(0, int(threads)):
+      process = multiprocessing.Process(target=run_http, args=(args,), daemon=True)
+      processes.append(process)
+      process.start()
+    try:
+      for process in processes:
+        process.join()
+    except KeyboardInterrupt:
+      pass
+  
+  else:
+    if threads != 0:
+      logging.warn("the --threads option is not supported on this platform")
+    run_http(args)

{wisp_python-0.6.1 → wisp_python-0.8.0}/src/wisp/server/http.py

@@ -41,9 +41,7 @@ async def static_handler(path, request_headers):
   if "Upgrade" in request_headers:
     return
     
-  response_headers = [
-    ("Server", f"wisp-server-python v{wisp.version}")
-  ]
+  response_headers = []
   target_path = static_path / path[1:]
 
   if target_path.is_dir():
@@ -61,31 +59,44 @@ async def static_handler(path, request_headers):
 
 async def main(args):
   global static_path
-  logging.info(f"running wisp-server-python v{wisp.version} (async)")
 
   if args.static:
     static_path = pathlib.Path(args.static).resolve()
     request_handler = static_handler
     mimetypes.init()
-    logging.info(f"serving static files from {static_path}")
   else:
     request_handler = None
   
   if args.limits:
-    logging.info("enabled rate limits")
     ratelimit.enabled = True
     ratelimit.connections_limit = int(args.connections)
     ratelimit.bandwidth_limit = float(args.bandwidth)
     ratelimit.window_size = float(args.window)
+  
+  if args.proxy:
+    if args.proxy.startswith("socks5h:"):
+      net.proxy_url = args.proxy.replace("socks5h:", "socks5:", 1)
+      net.proxy_dns = True
+    elif args.proxy.startswith("socks4a:"):
+      net.proxy_url = args.proxy.replace("socks4a:", "socks4:", 1)
+      net.proxy_dns = True
+    else:
+      net.proxy_url = args.proxy
+      net.proxy_dns = False
 
   net.block_loopback = not args.allow_loopback
   net.block_private = not args.allow_private
       
   limit_task = asyncio.create_task(ratelimit.reset_limits_timer())
-  logging.info(f"listening on {args.host}:{args.port}")
-
   ws_logger = logging.getLogger("websockets")
   ws_logger.setLevel(logging.WARN)
 
-  async with serve(connection_handler, args.host, int(args.port), process_request=request_handler, compression=None):
+  reuse_port = net.reuse_port_supported()
+  server_header = f"wisp-server-python v{wisp.version}"
+
+  async with serve(
+    connection_handler, args.host, int(args.port), 
+    reuse_port=reuse_port, process_request=request_handler, 
+    compression=None, server_header=server_header
+  ):
     await asyncio.Future()

{wisp_python-0.6.1 → wisp_python-0.8.0}/src/wisp/server/net.py

@@ -1,14 +1,29 @@
-import asyncudp
 import asyncio
 import socket
 import ipaddress
 
+import asyncudp
+from python_socks.async_.asyncio import Proxy
+
 #various network utilities and wrappers
 
 tcp_size = 64*1024
 block_loopback = False
 block_private = False
 
+proxy_url = None
+proxy_dns = False
+
+def reuse_port_supported():
+  return hasattr(socket, "SO_REUSEPORT")
+
+def is_ip(addr_str):
+  try:
+    ipaddress.ip_address(addr_str)
+    return True
+  except:
+    return False
+
 def get_ip(host, port, stream_type):
   if stream_type == 0x01:
     proto = socket.IPPROTO_TCP
@@ -21,7 +36,7 @@ async def get_ip_async(host, port, stream_type):
   loop = asyncio.get_running_loop()
   return await loop.run_in_executor(None, get_ip, host, port, stream_type)
 
-def validate_ip(addr_str):
+def validate_ip(addr_str):  
   ip_addr = ipaddress.ip_address(addr_str)
   if block_loopback and ip_addr.is_loopback:
     raise TypeError("Connection to loopback ip address blocked.")
@@ -29,9 +44,15 @@ def validate_ip(addr_str):
     raise TypeError("Connection to private ip address blocked.")
 
 async def validate_hostname(host, port, stream_type):
-  addr_str = await get_ip_async(host, port, stream_type)
-  validate_ip(addr_str)
-  return addr_str
+  if is_ip(host):
+    return validate_ip(host)
+  #don't do a dns lookup when we're on a proxy and using remote dns
+  elif proxy_url and proxy_dns:
+    return None
+  else:  
+    addr_str = await get_ip_async(host, port, stream_type)
+    validate_ip(addr_str)
+    return addr_str
 
 class TCPConnection:
   def __init__(self, hostname, port):
@@ -42,7 +63,20 @@ class TCPConnection:
   
   async def connect(self):
     addr_str = await validate_hostname(self.hostname, self.port, 0x01)
-    self.tcp_reader, self.tcp_writer = await asyncio.open_connection(host=addr_str, port=self.port, limit=tcp_size)
+    if proxy_url:
+      proxy = Proxy.from_url(proxy_url, rdns=proxy_dns)
+      proxy_dest = self.hostname if proxy_dns else addr_str
+      sock = await proxy.connect(dest_host=proxy_dest, dest_port=self.port)
+      self.tcp_reader, self.tcp_writer = await asyncio.open_connection(
+        limit=tcp_size, 
+        sock=sock
+      )
+    else:
+      self.tcp_reader, self.tcp_writer = await asyncio.open_connection(
+        host=addr_str, 
+        port=self.port,
+        limit=tcp_size,
+      )
   
   async def recv(self):
     return await self.tcp_reader.read(tcp_size)
@@ -65,6 +99,8 @@ class UDPConnection:
     self.socket = None
   
   async def connect(self):
+    if proxy_url:
+      raise NotImplementedError("SOCKS/HTTP proxy is not supported for UDP.")
     addr_str = await validate_hostname(self.hostname, self.port, 0x02)
     self.socket = await asyncudp.create_socket(remote_addr=(addr_str, self.port))
   

{wisp_python-0.6.1 → wisp_python-0.8.0/src/wisp_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wisp-python
-Version: 0.6.1
+Version: 0.8.0
 Summary: An implementation of a Wisp proxy server in Python
 Author: ading2210
 Project-URL: Homepage, https://github.com/MercuryWorkshop/wisp-server-python
@@ -11,8 +11,10 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
+License-File: LICENSE_third_party.md
 Requires-Dist: websockets
 Requires-Dist: asyncudp
+Requires-Dist: python-socks[asyncio]
 Requires-Dist: uvloop; sys_platform != "win32" and sys_platform != "cygwin"
 Dynamic: license-file
 
@@ -36,18 +38,14 @@ pip3 install wisp-python
 ```
 
 ## Running the Server:
-There are two different versions of the server:
-- Async (`wisp.server`) - The default, based on asyncio. It is more stable, but slower.
-- Threading (`wisp.server.threading`) - An faster alternative based on threading. It is about 40-80% faster, but possibly unstable. If you use Python's experimental [free threading](https://docs.python.org/3/howto/free-threading-python.html) builds, performance will scale linearly with your available CPU cores.
-
 For the best performance use [CPython](https://github.com/python/cpython) 3.11 or newer. [PyPy](https://github.com/pypy/pypy) is not recommended as it is a lot slower than CPython here. 
 
-To start the server, run `python3 -m wisp.server` (or `python3 -m wisp.server.threading`). The program accepts the following arguments:
+To start the server, run `python3 -m wisp.server`. The program accepts the following arguments:
 ```
 usage: wisp-server-python [-h] [--host HOST] [--port PORT] [--static STATIC] [--limits] [--bandwidth BANDWIDTH] [--connections CONNECTIONS] [--window WINDOW] [--allow-loopback] [--allow-private]
-                          [--log-level LOG_LEVEL]
+                          [--log-level LOG_LEVEL] [--threads THREADS] [--proxy PROXY]
 
-A Wisp server implementation, written in Python (v0.5.0)
+A Wisp server implementation, written in Python (v0.8.0)
 
 options:
   -h, --help            show this help message and exit
@@ -64,6 +62,8 @@ options:
   --allow-private       Allow connections to private IP addresses.
   --log-level LOG_LEVEL
                         The log level (either debug, info, warning, error, or critical).
+  --threads THREADS     The number of threads to run the server on. By default it uses all CPU cores. (Linux only)
+  --proxy PROXY         The url of the socks5h, socks5, sock4a, socks4 or http proxy to use.
 ```
 
 ## Roadmap:
@@ -76,10 +76,12 @@ options:
 ## Copyright:
 This repository is licensed under the GNU AGPL v3.
 
+A few third party libraries are used. See [`LICENSE_third_party.md`](https://github.com/MercuryWorkshop/wisp-server-python/blob/main/LICENSE).
+
 ### Copyright Notice:
 ```
 wisp-server-python: a Wisp server implementation written in Python
-Copyright (C) 2024 Mercury Workshop
+Copyright (C) 2025 Mercury Workshop
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU Affero General Public License as published by

{wisp_python-0.6.1 → wisp_python-0.8.0}/src/wisp_python.egg-info/SOURCES.txt

@@ -1,20 +1,16 @@
 LICENSE
+LICENSE_third_party.md
 README.md
 pyproject.toml
 src/wisp/__init__.py
 src/wisp/util.py
 src/wisp/server/__init__.py
 src/wisp/server/__main__.py
-src/wisp/server/common.py
+src/wisp/server/cli.py
 src/wisp/server/connection.py
 src/wisp/server/http.py
 src/wisp/server/net.py
 src/wisp/server/ratelimit.py
-src/wisp/server/threading/__init__.py
-src/wisp/server/threading/__main__.py
-src/wisp/server/threading/connection.py
-src/wisp/server/threading/http.py
-src/wisp/server/threading/netsync.py
 src/wisp_python.egg-info/PKG-INFO
 src/wisp_python.egg-info/SOURCES.txt
 src/wisp_python.egg-info/dependency_links.txt

{wisp_python-0.6.1 → wisp_python-0.8.0}/src/wisp_python.egg-info/requires.txt

@@ -1,5 +1,6 @@
 websockets
 asyncudp
+python-socks[asyncio]
 
 [:sys_platform != "win32" and sys_platform != "cygwin"]
 uvloop

wisp_python-0.6.1/src/wisp/server/__main__.py

@@ -1,26 +0,0 @@
-import argparse
-import asyncio
-import sys
-
-try:
-  import uvloop
-  use_uvloop = True
-except ImportError:
-  use_uvloop = False
-
-from wisp.server import http 
-from wisp.server import common 
-
-if __name__ == "__main__":
-  args = common.setup_main()
-
-  try:
-    if use_uvloop:
-      uvloop.run(http.main(args))
-    else:
-      #uvloop doesn't support windows at all so we don't need to print the error
-      if not sys.platform in ("win32", "cygwin"):
-        logging.error("Importing uvloop failed. Falling back to asyncio, which is slower.")
-      asyncio.run(http.main(args))
-  except KeyboardInterrupt:
-    pass

wisp_python-0.6.1/src/wisp/server/common.py

@@ -1,30 +0,0 @@
-import argparse
-import logging
-
-import wisp
-
-def setup_main():
-  parser = argparse.ArgumentParser(
-    prog="wisp-server-python",
-    description=f"A Wisp server implementation, written in Python (v{wisp.version})"
-  )
-
-  parser.add_argument("--host", default="127.0.0.1", help="The hostname the server will listen on.")
-  parser.add_argument("--port", default=6001, help="The TCP port the server will listen on.")
-  parser.add_argument("--static", help="Where static files are served from.")
-  parser.add_argument("--limits", action="store_true", help="Enable rate limits.")
-  parser.add_argument("--bandwidth", default=1000, help="Bandwidth limit per IP, in kilobytes per second.")
-  parser.add_argument("--connections", default=30, help="New connections limit per IP.")
-  parser.add_argument("--window", default=60, help="Fixed window length for rate limits, in seconds.")
-  parser.add_argument("--allow-loopback", action="store_true",help="Allow connections to loopback IP addresses.")
-  parser.add_argument("--allow-private", action="store_true", help="Allow connections to private IP addresses.")
-  parser.add_argument("--log-level", default="info", help="The log level (either debug, info, warning, error, or critical).")
-  args = parser.parse_args()
-
-  logging.basicConfig(
-    format="[%(asctime)s] %(levelname)-8s %(message)s",
-    level=getattr(logging, args.log_level.upper()),
-    datefmt="%Y/%m/%d - %H:%M:%S"
-  )
-
-  return args

wisp_python-0.6.1/src/wisp/server/threading/__init__.py

@@ -1,2 +0,0 @@
-from wisp.server.threading.connection import WispConnection
-from wisp.server.threading.connection import WSProxyConnection

wisp_python-0.6.1/src/wisp/server/threading/__main__.py

@@ -1,6 +0,0 @@
-from wisp.server.threading import http 
-from wisp.server import common 
-
-if __name__ == "__main__":
-  args = common.setup_main()
-  http.main(args)

wisp_python-0.6.1/src/wisp/server/threading/connection.py

@@ -1,219 +0,0 @@
-import struct
-import os
-import logging
-import queue
-import threading
-
-from websockets.exceptions import ConnectionClosed, ConnectionClosedError
-
-from wisp.server import ratelimit
-from wisp.server.threading import netsync
-
-queue_size = 128
-static_path = None
-
-#wisp packet format definitions
-#see https://docs.python.org/3/library/struct.html for what these characters mean
-packet_format = "<BI"
-connect_format = "<BH"
-continue_format = "<I"
-close_format = "<B"
-
-class WSProxyConnection:
-  def __init__(self, ws, path, client_ip):
-    self.ws = ws
-    self.path = path
-    self.client_ip = client_ip
-
-  def setup_connection(self):
-    addr_str = self.path.split("/")[-1]
-    self.tcp_host, self.tcp_port = addr_str.split(":")
-    self.tcp_port = int(self.tcp_port)
-
-    try:
-      self.conn = netsync.TCPConnection(self.tcp_host, self.tcp_port)
-      self.conn.connect()
-    except Exception as e:
-      logging.info(f"Creating a WSProxy stream to {self.tcp_host}:{self.tcp_port} failed: {e}")
-      self.ws.close()
-
-  def handle_ws(self):
-    while True:
-      try:
-        data = self.ws.recv()
-      except (ConnectionClosed, ConnectionClosedError) as e:
-        break
-
-      ratelimit.limit_client_bandwidth_sync(self.client_ip, len(data), "ws")
-      self.conn.send(data)
-    
-    self.conn.close()
-  
-  def handle_tcp(self):
-    while True:
-      data = self.conn.recv()
-      if len(data) == 0:
-        break #socket closed
-
-      ratelimit.limit_client_bandwidth_sync(self.client_ip, len(data), "tcp")
-      self.ws.send(data)
-    
-    self.ws.close()
-
-class WispConnection:
-  def __init__(self, ws, path, client_ip, id=None):
-    self.ws = ws
-    self.path = path
-    self.active_streams = {}
-    self.client_ip = client_ip
-    self.id = id
-  
-  #send the initial CONTINUE packet
-  def setup(self):
-    continue_payload = struct.pack(continue_format, queue_size)
-    continue_packet = struct.pack(packet_format, 0x03, 0) + continue_payload
-    self.ws.send(continue_packet)
-  
-  def close(self):
-    #close all active streams when the websocket disconnects
-    for stream_id in list(self.active_streams.keys()):
-      self.close_stream(stream_id)
-    self.ws.close()
-
-  def new_stream(self, stream_id, payload):
-    stream_type, destination_port = struct.unpack(connect_format, payload[:3])
-    hostname = bytes(payload[3:]).decode()
-    logging.debug(f"({self.id}) Creating a new stream to {hostname}:{destination_port}")
-
-    #rate limited
-    stream_count = ratelimit.get_client_attr(self.client_ip, "streams")
-    if ratelimit.enabled and stream_count > ratelimit.connections_limit:
-      self.send_close_packet(stream_id, 0x49)
-      self.close_stream(stream_id)
-      return
-    
-    #info looks valid - try to open the connection now
-    try:
-      if stream_type == 0x01:
-        connection = netsync.TCPConnection(hostname, destination_port)
-      elif stream_type == 0x02: 
-        connection = netsync.UDPConnection(hostname, destination_port)
-      else:
-        raise Exception("Invalid stream type.")
-      self.active_streams[stream_id]["conn"] = connection
-      connection.connect()
-        
-    except Exception as e:
-      logging.warn(f"({self.id}) Creating a new stream to {hostname}:{destination_port} failed: {e}")
-      self.send_close_packet(stream_id, 0x42)
-      self.close_stream(stream_id)
-      return
-    
-    self.active_streams[stream_id]["type"] = stream_type
-    threading.Thread(target=self.stream_ws_to_tcp, args=(stream_id,), daemon=True).start()
-    threading.Thread(target=self.stream_tcp_to_ws, args=(stream_id,), daemon=True).start()
-    ratelimit.inc_client_attr(self.client_ip, "streams")
-  
-  def stream_ws_to_tcp(self, stream_id):
-    while True: 
-      stream = self.active_streams[stream_id]
-      data = stream["queue"].get()
-      if data is None:
-        break
-      try:
-        stream["conn"].send(data)
-      except:
-        break
-
-      #send a CONTINUE packet periodically
-      stream["packets_sent"] += 1
-      if stream["packets_sent"] % (queue_size // 4) == 0:
-        buffer_remaining = stream["queue"].maxsize - stream["queue"].qsize()
-        continue_payload = struct.pack(continue_format, buffer_remaining)
-        continue_packet = struct.pack(packet_format, 0x03, stream_id) + continue_payload
-        self.ws.send(continue_packet)
-  
-  def stream_tcp_to_ws(self, stream_id):
-    while True:
-      stream = self.active_streams[stream_id]
-      try:
-        data = stream["conn"].recv()
-      except Exception as e:
-        logging.warn(f"({self.id}) Receiving data from stream failed: {e}")
-        self.send_close_packet(stream_id, 0x03)
-        self.close_stream(stream_id)
-        return
-        
-      if len(data) == 0: #connection closed
-        break
-      data_header = struct.pack(packet_format, 0x02, stream_id)
-
-      ratelimit.limit_client_bandwidth_sync(self.client_ip, len(data_header)+len(data), "tcp")
-      try:
-        self.ws.send(data_header + data)
-      except (ConnectionClosed, ConnectionClosedError) as e:
-        return
-
-    self.send_close_packet(stream_id, 0x02)
-    self.close_stream(stream_id)
-  
-  def send_close_packet(self, stream_id, reason):
-    if not stream_id in self.active_streams:
-      return
-    close_payload = struct.pack(close_format, reason)
-    close_packet = struct.pack(packet_format, 0x04, stream_id) + close_payload
-    self.ws.send(close_packet)
-  
-  def close_stream(self, stream_id):
-    if not stream_id in self.active_streams:
-      return #stream already closed
-    stream = self.active_streams[stream_id]
-    if stream["conn"]:
-      stream["conn"].close()
-
-    #empty the queue and kill it
-    while not stream["queue"].empty():
-      stream["queue"].get()
-    stream["queue"].put(None)
-    del self.active_streams[stream_id]
-  
-  def handle_ws(self):
-    while True:
-      try:
-        data = self.ws.recv()
-      except (ConnectionClosed, ConnectionClosedError):
-        break
-      except Exception as e:
-        logging.warn(f"({self.id}) Receiving data from websocket failed: {e}")
-        break
-
-      if not isinstance(data, bytes): 
-        continue #ignore non binary frames
-      
-      #implement bandwidth limits
-      ratelimit.limit_client_bandwidth_sync(self.client_ip, len(data), "ws")
-      
-      #get basic packet info
-      payload = memoryview(data)[5:]
-      packet_type, stream_id = struct.unpack(packet_format, data[:5])
-
-      if packet_type == 0x01: #CONNECT packet
-        self.active_streams[stream_id] = {
-          "conn": None,
-          "type": None,
-          "queue": queue.Queue(queue_size),
-          "packets_sent": 0
-        }
-        threading.Thread(target=self.new_stream, args=(stream_id, payload), daemon=True).start()
-      
-      elif packet_type == 0x02: #DATA packet
-        stream = self.active_streams.get(stream_id)
-        if not stream:
-          continue
-        stream["queue"].put(payload)
-      
-      elif packet_type == 0x04: #CLOSE packet
-        reason = struct.unpack(close_format, payload)[0]
-        self.close_stream(stream_id)
-
-    self.close()

wisp_python-0.6.1/src/wisp/server/threading/http.py

@@ -1,104 +0,0 @@
-import threading
-import multiprocessing
-import pathlib
-import mimetypes
-import logging
-import random
-import sys
-
-from websockets.sync.server import serve
-from websockets.http11 import Response, Headers
-
-import wisp
-from wisp.server import ratelimit
-from wisp.server import net
-from wisp.server.threading import connection
-
-static_path = None
-connections = {}
-
-def connection_handler(websocket):
-  path = websocket.request.path
-  client_ip = websocket.remote_address[0]
-  if client_ip == "127.0.0.1" and "X-Real-IP" in websocket.request.headers:
-    client_ip = websocket.request.headers["X-Real-IP"]
-  origin = websocket.request.headers.get("Origin")
-
-  conn_id = "".join(random.choices("1234567890abcdef", k=8))
-  logging.info(f"({conn_id}) incoming connection on {path} from {client_ip} (origin: {origin})")
-  ratelimit.inc_client_attr(client_ip, "streams")
-
-  if path.endswith("/"):
-    wisp_conn = connection.WispConnection(websocket, path, client_ip, conn_id)
-    connections[websocket] = wisp_conn
-    wisp_conn.setup()
-    wisp_conn.handle_ws()
-    del connections[websocket]
-
-  else:
-    stream_count = ratelimit.get_client_attr(client_ip, "streams")
-    if ratelimit.enabled and stream_count > ratelimit.connections_limit:
-      return
-    wsproxy_conn = connection.WSProxyConnection(websocket, path, client_ip)
-    wsproxy_conn.setup_connection()
-    t1 = threading.Thread(target=wsproxy_conn.handle_ws, daemon=True)
-    t2 = threading.Thread(target=wsproxy_conn.handle_tcp, daemon=True)
-    t1.start(); t2.start()
-    t1.join(); t2.join()
-
-def static_handler(connection, request):
-  if "Upgrade" in request.headers:
-    return
-    
-  response_headers = Headers()
-  response_headers["Server"] = f"wisp-server-python v{wisp.version}"
-  if static_path is None:
-    return Response(204, None, response_headers, body=b"")
-
-  target_path = static_path / request.path[1:]
-
-  if target_path.is_dir():
-    target_path = target_path / "index.html"
-  if not target_path.is_relative_to(static_path):
-    return Response(403, None, response_headers, body="403 forbidden".encode())
-  if not target_path.exists():
-    return Response(404, None, response_headers, body="404 not found".encode())
-  
-  mimetype = mimetypes.guess_type(target_path.name)[0]
-  response_headers["Content-Type"] = mimetype
-
-  static_data = target_path.read_bytes()
-  return Response(200, None, response_headers, body=static_data)
-
-def main(args):
-  global static_path
-  logging.info(f"running wisp-server-python v{wisp.version} (threading)")
-
-  if args.static:
-    static_path = pathlib.Path(args.static).resolve()
-    mimetypes.init()
-    logging.info(f"serving static files from {static_path}")
-  
-  if args.limits:
-    logging.info("enabled rate limits")
-    ratelimit.enabled = True
-    ratelimit.connections_limit = int(args.connections)
-    ratelimit.bandwidth_limit = float(args.bandwidth)
-    ratelimit.window_size = float(args.window)
-
-  net.block_loopback = not args.allow_loopback
-  net.block_private = not args.allow_private
-      
-  threading.Thread(target=ratelimit.reset_limits_timer_sync, daemon=True).start()
-  logging.info(f"listening on {args.host}:{args.port}")
-
-  ws_logger = logging.getLogger("websockets")
-  ws_logger.setLevel(logging.WARN)
-
-  with serve(connection_handler, args.host, int(args.port), process_request=static_handler, compression=None) as server:
-    try:
-      server.serve_forever()
-    except KeyboardInterrupt:
-      for connection in connections.values():
-        connection.close()
-      server.shutdown()

wisp_python-0.6.1/src/wisp/server/threading/netsync.py

@@ -1,58 +0,0 @@
-import socket
-import ipaddress
-
-#various network utilities and wrappers - synchronous version
-
-from wisp.server import net
-
-def validate_hostname(host, port, stream_type):
-  addr_str = net.get_ip(host, port, stream_type)
-  net.validate_ip(addr_str)
-  return addr_str
-
-class TCPConnection:
-  def __init__(self, hostname, port):
-    self.hostname = hostname
-    self.port = port
-    self.socket = None
-  
-  def connect(self):
-    addr_str = validate_hostname(self.hostname, self.port, 0x01)
-    self.socket = socket.socket()
-    self.socket.connect((self.hostname, self.port))
-  
-  def recv(self):
-    return self.socket.recv(net.tcp_size)
-  
-  def send(self, data):
-    self.socket.send(data)
-  
-  def close(self):
-    if self.socket is None:
-      return
-    self.socket.shutdown(socket.SHUT_RDWR)
-    self.socket.close()
-
-class UDPConnection:
-  def __init__(self, hostname, port):
-    self.hostname = hostname
-    self.port = port
-    self.socket = None
-  
-  def connect(self):
-    addr_str = validate_hostname(self.hostname, self.port, 0x02)
-    self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-    self.socket.bind((self.hostname, self.port))
-  
-  def recv(self):
-    data, addr = self.socket.recvfrom(net.tcp_size)
-    return data
-  
-  def send(self, data):
-    self.socket.sendto(data, (self.hostname, self.port))
-  
-  def close(self):
-    if self.socket is None:
-      return
-    self.socket.shutdown(socket.SHUT_RDWR)
-    self.socket.close()