asyncproxy 1.0__tar.gz

asyncproxy-1.0/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2010-2025 Sippy Software, Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+
+2. 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.
+
+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.

asyncproxy-1.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include src/Symbol.map src/asp_iostats.h src/asp_sock.So src/asp_sock.c src/asp_sock.h src/asyncproxy.So src/asyncproxy.c src/asyncproxy.h
+include README.md

asyncproxy-1.0/PKG-INFO

@@ -0,0 +1,213 @@
+Metadata-Version: 2.4
+Name: asyncproxy
+Version: 1.0
+Summary: Background TCP proxy for async IO
+Home-page: https://github.com/sippy/libasyncproxy.git
+Author: Maksym Sobolyev
+Author-email: sobomax@sippysoft.com
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: summary
+
+# libasyncproxy
+
+## Introduction
+
+The libasyncproxy is a fairy simple C library and a respective python wrapper,
+which allows splicing two sockets, pipes and in general file descriptors to
+relay bidirectional data in/out in a background using a worker thread (one per
+connection at the moment).
+
+Unlike system-wide facilities that might be offering similar functionality,
+this library provides more control and flexibility. Allowing to connect
+different kinds of underlying objects (i.e. plain file to a socket, device to
+a pipe etc).
+
+It also privides mechanism for the python code to supply a handler(s) to
+monitor, record and/or alter the data being transmitted.
+
+Last but not least, the C library can be used directly from a low-level code
+for the same effect.
+
+## History
+
+The code was created to allow Python code implementing application-layer proxy
+to manage session routing and connection, while handling all transfers outside
+of confinments of the slow Python and its GIL.
+
+## Interfaces
+
+AsyncProxy: the lowest-level interface, dealing with raw sockets, wrapper for
+libasyncproxy.
+
+ForwarderFast: super-set of AsyncProxy with some utility methods.
+
+Forwarder: same API and functionality as ForwarderFast, but without using
+AsyncProxy C module (i.e. python thread doing i/o). Mostly for backward
+compatibility when we need to break library API.
+
+TCPProxy: set of high-level classes to accept and manage inbound connections
+and initiate/tear-down outbound as needed, connecting them using forwarders
+once established. Will use ForwarderFast if available, falling back to the
+Forwarder if that fails to load or initialize.
+
+## Use Cases
+
+We use this library to allow applications to be redirected to one of several
+available DB replicas and re-routed instantly if the configuration changes.
+
+## Build and Install Python module from source code:
+
+```
+git clone https://github.com/sippy/libasyncproxy.git
+pip install libasyncproxy/
+```
+
+## Usage
+
+### asyncproxy -- `AsyncProxy2FD` Example
+
+This example shows how to set up a bidirectional relay between two socket pairs using `AsyncProxy2FD`. Data sent on one end is forwarded to the other, and vice versa.
+
+```python
+import socket
+from asyncproxy.AsyncProxy import AsyncProxy2FD
+
+# 1. Create two socket pairs:
+#    - (client_socket, proxy_in): client writes to `proxy_in`
+#    - (proxy_out, server_socket): proxy writes to `proxy_out`, server reads
+client_socket, proxy_in     = socket.socketpair()
+proxy_out,    server_socket = socket.socketpair()
+
+# 2. Initialize and start the proxy:
+proxy = AsyncProxy2FD(proxy_in.fileno(), proxy_out.fileno())
+proxy.start()
+
+# 3. Send from client → server:
+client_msg = b"Hello from Client!"
+client_socket.sendall(client_msg)
+print("Client sent:", client_msg.decode())
+
+server_recv = server_socket.recv(1024)
+print("Server received:", server_recv.decode())
+
+# 4. Send from server → client:
+server_msg = b"Hello from Server!"
+server_socket.sendall(server_msg)
+print("Server sent:", server_msg.decode())
+
+client_recv = client_socket.recv(1024)
+print("Client received:", client_recv.decode())
+
+# 5. Shutdown and cleanup:
+proxy.join(shutdown=True)
+for sock in (client_socket, proxy_in, proxy_out, server_socket):
+    sock.close()
+```
+
+### asyncproxy -- `TCPProxy` Example
+
+This example shows how to set up a TCP proxy accepting connections on
+`localhost:8080` and forwarding it to `www.google.com:80`.
+
+```python
+import socket
+from time import sleep
+from asyncproxy.TCPProxy import TCPProxy
+
+# 1. Initialize and start the proxy:
+#    - Listen on local port 8080
+#    - Forward all traffic to www.google.com:80
+proxy = TCPProxy(port=8080, newhost='www.google.com', newport=80)
+proxy.start()
+print("TCPProxy running on:", proxy.sock.getsockname())
+
+# 2. Connect via the proxy and send HTTP requests twice
+for _ in (1, 2):
+    with socket.create_connection(('127.0.0.1', 8080)) as s:
+        print("Connected to www.google.com via TCPProxy.")
+        s.sendall(b"GET / HTTP/1.0\r\nHost: www.google.com\r\n\r\n")
+        resp = s.recv(256)
+        print("Response received from proxy:")
+        print(resp.decode('utf-8', errors='replace'))
+
+# 3. Shutdown the proxy cleanly
+proxy.shutdown()
+```
+
+### asyncproxy -- Advanced `AsyncProxy2FD` Example
+
+This example shows how to subclass `AsyncProxy2FD` to inspect and modify data in transit using custom `in2out` and `out2in` hooks.
+
+```python
+import socket
+from ctypes import string_at, memmove
+from asyncproxy.AsyncProxy import AsyncProxy2FD
+
+class NosyProxy(AsyncProxy2FD):
+    def in2out(self, res_p):
+        # Unpack the struct
+        tr = res_p.contents
+        ptr, length = tr.buf, tr.len
+
+        # Read original bytes, transform, and write back
+        original    = string_at(ptr, length)
+        length     -= 1
+        transformed = original.upper()[:length]
+        memmove(ptr, transformed, length)
+        tr.len = length
+
+        print("in2out hook:", original, "→", transformed)
+
+    def out2in(self, res_p):
+        tr = res_p.contents
+        ptr, length = tr.buf, tr.len
+
+        original    = string_at(ptr, length)
+        length     -= 1
+        transformed = original[::-1][1:]
+        memmove(ptr, transformed, length)
+        tr.len = length
+
+        print("out2in hook:", original, "→", transformed)
+
+# 1. Create two socket pairs for bidirectional flow
+client_socket, proxy_in       = socket.socketpair()
+proxy_out,    server_socket   = socket.socketpair()
+
+# 2. Initialize and start the custom proxy
+proxy = NosyProxy(proxy_in.fileno(), proxy_out.fileno())
+proxy.start()
+
+# 3. Client → Server (uppercase transformation)
+client_msg = b"Hello from Client!"
+client_socket.sendall(client_msg)
+print("Client sent:", client_msg.decode())
+
+srv_recv = server_socket.recv(1024)
+print("Server received:", srv_recv.decode())
+
+# 4. Server → Client (reverse transformation)
+server_msg = b"Hello from Server!"
+server_socket.sendall(server_msg)
+print("Server sent:", server_msg.decode())
+
+cli_recv = client_socket.recv(1024)
+print("Client received:", cli_recv.decode())
+
+# 5. Shutdown and cleanup
+proxy.join(shutdown=True)
+for sock in (client_socket, proxy_in, proxy_out, server_socket):
+    sock.close()
+```

asyncproxy-1.0/README.md

@@ -0,0 +1,191 @@
+# libasyncproxy
+
+## Introduction
+
+The libasyncproxy is a fairy simple C library and a respective python wrapper,
+which allows splicing two sockets, pipes and in general file descriptors to
+relay bidirectional data in/out in a background using a worker thread (one per
+connection at the moment).
+
+Unlike system-wide facilities that might be offering similar functionality,
+this library provides more control and flexibility. Allowing to connect
+different kinds of underlying objects (i.e. plain file to a socket, device to
+a pipe etc).
+
+It also privides mechanism for the python code to supply a handler(s) to
+monitor, record and/or alter the data being transmitted.
+
+Last but not least, the C library can be used directly from a low-level code
+for the same effect.
+
+## History
+
+The code was created to allow Python code implementing application-layer proxy
+to manage session routing and connection, while handling all transfers outside
+of confinments of the slow Python and its GIL.
+
+## Interfaces
+
+AsyncProxy: the lowest-level interface, dealing with raw sockets, wrapper for
+libasyncproxy.
+
+ForwarderFast: super-set of AsyncProxy with some utility methods.
+
+Forwarder: same API and functionality as ForwarderFast, but without using
+AsyncProxy C module (i.e. python thread doing i/o). Mostly for backward
+compatibility when we need to break library API.
+
+TCPProxy: set of high-level classes to accept and manage inbound connections
+and initiate/tear-down outbound as needed, connecting them using forwarders
+once established. Will use ForwarderFast if available, falling back to the
+Forwarder if that fails to load or initialize.
+
+## Use Cases
+
+We use this library to allow applications to be redirected to one of several
+available DB replicas and re-routed instantly if the configuration changes.
+
+## Build and Install Python module from source code:
+
+```
+git clone https://github.com/sippy/libasyncproxy.git
+pip install libasyncproxy/
+```
+
+## Usage
+
+### asyncproxy -- `AsyncProxy2FD` Example
+
+This example shows how to set up a bidirectional relay between two socket pairs using `AsyncProxy2FD`. Data sent on one end is forwarded to the other, and vice versa.
+
+```python
+import socket
+from asyncproxy.AsyncProxy import AsyncProxy2FD
+
+# 1. Create two socket pairs:
+#    - (client_socket, proxy_in): client writes to `proxy_in`
+#    - (proxy_out, server_socket): proxy writes to `proxy_out`, server reads
+client_socket, proxy_in     = socket.socketpair()
+proxy_out,    server_socket = socket.socketpair()
+
+# 2. Initialize and start the proxy:
+proxy = AsyncProxy2FD(proxy_in.fileno(), proxy_out.fileno())
+proxy.start()
+
+# 3. Send from client → server:
+client_msg = b"Hello from Client!"
+client_socket.sendall(client_msg)
+print("Client sent:", client_msg.decode())
+
+server_recv = server_socket.recv(1024)
+print("Server received:", server_recv.decode())
+
+# 4. Send from server → client:
+server_msg = b"Hello from Server!"
+server_socket.sendall(server_msg)
+print("Server sent:", server_msg.decode())
+
+client_recv = client_socket.recv(1024)
+print("Client received:", client_recv.decode())
+
+# 5. Shutdown and cleanup:
+proxy.join(shutdown=True)
+for sock in (client_socket, proxy_in, proxy_out, server_socket):
+    sock.close()
+```
+
+### asyncproxy -- `TCPProxy` Example
+
+This example shows how to set up a TCP proxy accepting connections on
+`localhost:8080` and forwarding it to `www.google.com:80`.
+
+```python
+import socket
+from time import sleep
+from asyncproxy.TCPProxy import TCPProxy
+
+# 1. Initialize and start the proxy:
+#    - Listen on local port 8080
+#    - Forward all traffic to www.google.com:80
+proxy = TCPProxy(port=8080, newhost='www.google.com', newport=80)
+proxy.start()
+print("TCPProxy running on:", proxy.sock.getsockname())
+
+# 2. Connect via the proxy and send HTTP requests twice
+for _ in (1, 2):
+    with socket.create_connection(('127.0.0.1', 8080)) as s:
+        print("Connected to www.google.com via TCPProxy.")
+        s.sendall(b"GET / HTTP/1.0\r\nHost: www.google.com\r\n\r\n")
+        resp = s.recv(256)
+        print("Response received from proxy:")
+        print(resp.decode('utf-8', errors='replace'))
+
+# 3. Shutdown the proxy cleanly
+proxy.shutdown()
+```
+
+### asyncproxy -- Advanced `AsyncProxy2FD` Example
+
+This example shows how to subclass `AsyncProxy2FD` to inspect and modify data in transit using custom `in2out` and `out2in` hooks.
+
+```python
+import socket
+from ctypes import string_at, memmove
+from asyncproxy.AsyncProxy import AsyncProxy2FD
+
+class NosyProxy(AsyncProxy2FD):
+    def in2out(self, res_p):
+        # Unpack the struct
+        tr = res_p.contents
+        ptr, length = tr.buf, tr.len
+
+        # Read original bytes, transform, and write back
+        original    = string_at(ptr, length)
+        length     -= 1
+        transformed = original.upper()[:length]
+        memmove(ptr, transformed, length)
+        tr.len = length
+
+        print("in2out hook:", original, "→", transformed)
+
+    def out2in(self, res_p):
+        tr = res_p.contents
+        ptr, length = tr.buf, tr.len
+
+        original    = string_at(ptr, length)
+        length     -= 1
+        transformed = original[::-1][1:]
+        memmove(ptr, transformed, length)
+        tr.len = length
+
+        print("out2in hook:", original, "→", transformed)
+
+# 1. Create two socket pairs for bidirectional flow
+client_socket, proxy_in       = socket.socketpair()
+proxy_out,    server_socket   = socket.socketpair()
+
+# 2. Initialize and start the custom proxy
+proxy = NosyProxy(proxy_in.fileno(), proxy_out.fileno())
+proxy.start()
+
+# 3. Client → Server (uppercase transformation)
+client_msg = b"Hello from Client!"
+client_socket.sendall(client_msg)
+print("Client sent:", client_msg.decode())
+
+srv_recv = server_socket.recv(1024)
+print("Server received:", srv_recv.decode())
+
+# 4. Server → Client (reverse transformation)
+server_msg = b"Hello from Server!"
+server_socket.sendall(server_msg)
+print("Server sent:", server_msg.decode())
+
+cli_recv = client_socket.recv(1024)
+print("Client received:", cli_recv.decode())
+
+# 5. Shutdown and cleanup
+proxy.join(shutdown=True)
+for sock in (client_socket, proxy_in, proxy_out, server_socket):
+    sock.close()
+```

asyncproxy-1.0/asyncproxy.egg-info/PKG-INFO

@@ -0,0 +1,213 @@
+Metadata-Version: 2.4
+Name: asyncproxy
+Version: 1.0
+Summary: Background TCP proxy for async IO
+Home-page: https://github.com/sippy/libasyncproxy.git
+Author: Maksym Sobolyev
+Author-email: sobomax@sippysoft.com
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: summary
+
+# libasyncproxy
+
+## Introduction
+
+The libasyncproxy is a fairy simple C library and a respective python wrapper,
+which allows splicing two sockets, pipes and in general file descriptors to
+relay bidirectional data in/out in a background using a worker thread (one per
+connection at the moment).
+
+Unlike system-wide facilities that might be offering similar functionality,
+this library provides more control and flexibility. Allowing to connect
+different kinds of underlying objects (i.e. plain file to a socket, device to
+a pipe etc).
+
+It also privides mechanism for the python code to supply a handler(s) to
+monitor, record and/or alter the data being transmitted.
+
+Last but not least, the C library can be used directly from a low-level code
+for the same effect.
+
+## History
+
+The code was created to allow Python code implementing application-layer proxy
+to manage session routing and connection, while handling all transfers outside
+of confinments of the slow Python and its GIL.
+
+## Interfaces
+
+AsyncProxy: the lowest-level interface, dealing with raw sockets, wrapper for
+libasyncproxy.
+
+ForwarderFast: super-set of AsyncProxy with some utility methods.
+
+Forwarder: same API and functionality as ForwarderFast, but without using
+AsyncProxy C module (i.e. python thread doing i/o). Mostly for backward
+compatibility when we need to break library API.
+
+TCPProxy: set of high-level classes to accept and manage inbound connections
+and initiate/tear-down outbound as needed, connecting them using forwarders
+once established. Will use ForwarderFast if available, falling back to the
+Forwarder if that fails to load or initialize.
+
+## Use Cases
+
+We use this library to allow applications to be redirected to one of several
+available DB replicas and re-routed instantly if the configuration changes.
+
+## Build and Install Python module from source code:
+
+```
+git clone https://github.com/sippy/libasyncproxy.git
+pip install libasyncproxy/
+```
+
+## Usage
+
+### asyncproxy -- `AsyncProxy2FD` Example
+
+This example shows how to set up a bidirectional relay between two socket pairs using `AsyncProxy2FD`. Data sent on one end is forwarded to the other, and vice versa.
+
+```python
+import socket
+from asyncproxy.AsyncProxy import AsyncProxy2FD
+
+# 1. Create two socket pairs:
+#    - (client_socket, proxy_in): client writes to `proxy_in`
+#    - (proxy_out, server_socket): proxy writes to `proxy_out`, server reads
+client_socket, proxy_in     = socket.socketpair()
+proxy_out,    server_socket = socket.socketpair()
+
+# 2. Initialize and start the proxy:
+proxy = AsyncProxy2FD(proxy_in.fileno(), proxy_out.fileno())
+proxy.start()
+
+# 3. Send from client → server:
+client_msg = b"Hello from Client!"
+client_socket.sendall(client_msg)
+print("Client sent:", client_msg.decode())
+
+server_recv = server_socket.recv(1024)
+print("Server received:", server_recv.decode())
+
+# 4. Send from server → client:
+server_msg = b"Hello from Server!"
+server_socket.sendall(server_msg)
+print("Server sent:", server_msg.decode())
+
+client_recv = client_socket.recv(1024)
+print("Client received:", client_recv.decode())
+
+# 5. Shutdown and cleanup:
+proxy.join(shutdown=True)
+for sock in (client_socket, proxy_in, proxy_out, server_socket):
+    sock.close()
+```
+
+### asyncproxy -- `TCPProxy` Example
+
+This example shows how to set up a TCP proxy accepting connections on
+`localhost:8080` and forwarding it to `www.google.com:80`.
+
+```python
+import socket
+from time import sleep
+from asyncproxy.TCPProxy import TCPProxy
+
+# 1. Initialize and start the proxy:
+#    - Listen on local port 8080
+#    - Forward all traffic to www.google.com:80
+proxy = TCPProxy(port=8080, newhost='www.google.com', newport=80)
+proxy.start()
+print("TCPProxy running on:", proxy.sock.getsockname())
+
+# 2. Connect via the proxy and send HTTP requests twice
+for _ in (1, 2):
+    with socket.create_connection(('127.0.0.1', 8080)) as s:
+        print("Connected to www.google.com via TCPProxy.")
+        s.sendall(b"GET / HTTP/1.0\r\nHost: www.google.com\r\n\r\n")
+        resp = s.recv(256)
+        print("Response received from proxy:")
+        print(resp.decode('utf-8', errors='replace'))
+
+# 3. Shutdown the proxy cleanly
+proxy.shutdown()
+```
+
+### asyncproxy -- Advanced `AsyncProxy2FD` Example
+
+This example shows how to subclass `AsyncProxy2FD` to inspect and modify data in transit using custom `in2out` and `out2in` hooks.
+
+```python
+import socket
+from ctypes import string_at, memmove
+from asyncproxy.AsyncProxy import AsyncProxy2FD
+
+class NosyProxy(AsyncProxy2FD):
+    def in2out(self, res_p):
+        # Unpack the struct
+        tr = res_p.contents
+        ptr, length = tr.buf, tr.len
+
+        # Read original bytes, transform, and write back
+        original    = string_at(ptr, length)
+        length     -= 1
+        transformed = original.upper()[:length]
+        memmove(ptr, transformed, length)
+        tr.len = length
+
+        print("in2out hook:", original, "→", transformed)
+
+    def out2in(self, res_p):
+        tr = res_p.contents
+        ptr, length = tr.buf, tr.len
+
+        original    = string_at(ptr, length)
+        length     -= 1
+        transformed = original[::-1][1:]
+        memmove(ptr, transformed, length)
+        tr.len = length
+
+        print("out2in hook:", original, "→", transformed)
+
+# 1. Create two socket pairs for bidirectional flow
+client_socket, proxy_in       = socket.socketpair()
+proxy_out,    server_socket   = socket.socketpair()
+
+# 2. Initialize and start the custom proxy
+proxy = NosyProxy(proxy_in.fileno(), proxy_out.fileno())
+proxy.start()
+
+# 3. Client → Server (uppercase transformation)
+client_msg = b"Hello from Client!"
+client_socket.sendall(client_msg)
+print("Client sent:", client_msg.decode())
+
+srv_recv = server_socket.recv(1024)
+print("Server received:", srv_recv.decode())
+
+# 4. Server → Client (reverse transformation)
+server_msg = b"Hello from Server!"
+server_socket.sendall(server_msg)
+print("Server sent:", server_msg.decode())
+
+cli_recv = client_socket.recv(1024)
+print("Client received:", cli_recv.decode())
+
+# 5. Shutdown and cleanup
+proxy.join(shutdown=True)
+for sock in (client_socket, proxy_in, proxy_out, server_socket):
+    sock.close()
+```

asyncproxy-1.0/asyncproxy.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+MANIFEST.in
+README.md
+setup.py
+asyncproxy.egg-info/PKG-INFO
+asyncproxy.egg-info/SOURCES.txt
+asyncproxy.egg-info/dependency_links.txt
+asyncproxy.egg-info/top_level.txt
+python/AsyncProxy.py
+python/Forwarder.py
+python/ForwarderFast.py
+python/TCPProxy.py
+python/env.py
+src/Symbol.map
+src/asp_iostats.h
+src/asp_sock.c
+src/asp_sock.h
+src/asyncproxy.c
+src/asyncproxy.h

asyncproxy-1.0/asyncproxy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

asyncproxy-1.0/asyncproxy.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+_libasyncproxy
+asyncproxy