Example #1
0
Type some stuff into STDIN and you'll see it in the original netcat
server/listen session. A really simple (fast) proxy!

"""
import socket
import sys
import os
sys.path.append(".")
sys.path.append("..")

import duplex


backend_port = os.environ.get("PORT", 8000)

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
try:
    server.bind(("0.0.0.0", 10000))
    server.listen(1024)

    while True:
        conn, address = server.accept()
        backend = socket.create_connection(("0.0.0.0", backend_port))
        duplex.join(conn, backend)
finally:
    server.close()
    duplex.shutdown()

Example #2
0
        waiting_sockets = []

        while True:
            readables, writables, errs = select.select(
                                            watched_sockets,
                                            watched_sockets,
                                            [], 0)

            for readable in readables:
                if readable == server_backend:
                    conn, address = readable.accept()
                    waiting_sockets.append(conn)
                elif readable == server_frontend:
                    conn, address = readable.accept()
                    backend_conn = waiting_sockets.pop()
                    duplex.join(conn, backend_conn)
                else:
                    pass

    elif mode == "--client":
        local_port = sys.argv[2]
        watched_sockets = []

        for i in range(CLIENT_POOL_SIZE):
            conn = socket.create_connection(("0.0.0.0", BACKEND_PORT))
            conn.setblocking(0)
            watched_sockets.append(conn)

        while True:
            readables, writables, errs = select.select(
                                            watched_sockets,
Example #3
0
Everybody will get all streams. This could be modified to give each
connecting pair their own private port by building a small protocol to
provision ports to incoming connections and having them discover their
private port from the main server port.

"""
import socket
import sys
sys.path.append(".")
sys.path.append("..")

import duplex


connections = []

try:
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.bind(("0.0.0.0", 10000))
    server.listen(1024)

    while True:
        new_conn, address = server.accept()
        for conn in connections:
            duplex.join(new_conn, conn)
finally:
    duplex.shutdown()


Example #4
0
This looks like a lot, but since the joined sockets are managed by
megasock, you don't have to worry about them. In the end, this is what
we accomplish:

    pair1_left <--> pair2_right

"""
import socket
import sys
sys.path.append(".")
sys.path.append("..")

import duplex


try:
    pair1_left, pair1_right = socket.socketpair(socket.AF_UNIX, socket.SOCK_STREAM)
    pair2_left, pair2_right = socket.socketpair(socket.AF_UNIX, socket.SOCK_STREAM)

    duplex.join(pair1_right, pair2_left)

    pair1_left.send("Hello from pair1")
    print "pair2 got:", pair2_right.recv(1024)

    pair2_right.send("Hello from pair2")
    print "pair1 got:", pair1_left.recv(1024)

finally:
    duplex.shutdown()