Need help creating a TCP relay between two sockets

I have the following situation:

SomeServer(S) <-> (C)MyApp(S) <-> (C)User

(S) represents a server socket
(C) represents a client socket

Essentially, MyApp initiates communication with SomeServer (SomeServer(S) <-> (C)MyApp) and once some authentication routines are successful MyApp(S) starts waiting for (C)User to connect. As soon as User connects, MyApp relays data from SomeServer to User. This happens in both directions.

I have SomeServer(S) <-> (C)MyApp working perfectly, but I'm not able to get MyApp(S) <-> (C)User working. I get as far as User connecting to MyApp(S), but can't get data relayed!

Ok, I hope that's some what clear ;) Now let me show my code for MyApp. Btw the implementation of SomeServer and User are not relevant for solving my question, as neither can be modified.

I have commented my code indicating where I'm experiencing issues. Oh, I should also mention that I have no problem scrapping the whole "Server Section" for some other code if necessary. This is a POC, so my main focus is getting the functionality working rather than writing efficient code. Thanks for you time.

''' MyApp.py module '''

import asyncore, socket
import SSL

# Client Section
# Connects to SomeServer

class MyAppClient(asyncore.dispatcher):

    def __init__(self, host, port):
        asyncore.dispatcher.__init__(self)
        self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
        self.connect((host, port))

    connectionPhase = 1
    def handle_read(self):
        print "connectionPhase =", self.connectionPhase

    # The following IF statements may not make sense
    # as I have removed code irrelevant to this question

    if self.connectionPhase < 3: # authentication phase
            data = self.recv(1024)
            print 'Received:', data

            # Client/Server authentication is handled here
            # Everything from this point on happens over
            # an encrypted socket using SSL

            # Start the RelayServer listening on localhost 8080
            # self.socket is encrypted and is the socket communicating
            # with SomeServer

            rs = RelayServer(('localhost', 8080), self.socket)
            print 'RelaySe开发者_如何学JAVArver started'

        # connectionPhase = 3 when this IF loop is done

        elif self.connectionPhase == 3: # receiving data for User
            data = self.recv(1024)

            print 'Received data - forward to User:', data

            # Forward this data to User
            # Don't understand why data is being read here
            # when the RelayServer was instantiated above

# Server Section
# Connects to User

class RelayConnection(asyncore.dispatcher):
    def __init__(self, client, sock):
        asyncore.dispatcher.__init__(self)
        self.client = client
        print "connecting to %s..." % str(sock)

    def handle_connect(self):
        print "connected."
        # Allow reading once the connection
        # on the other side is open.
        self.client.is_readable = True


    # For some reason this never runs, i.e. data from SomeServer
    # isn't read here, but instead in MyAppClient.handle_read()
    # don't know how to make it arrive here instead as it should
    # be relayed to User

    def handle_read(self):
        self.client.send(self.recv(1024))

class RelayClient(asyncore.dispatcher):
    def __init__(self, server, client, sock):
        asyncore.dispatcher.__init__(self, client)
        self.is_readable = False
        self.server = server
        self.relay = RelayConnection(self, sock)

    def handle_read(self):
        self.relay.send(self.recv(1024))

    def handle_close(self):
        print "Closing relay..."
        # If the client disconnects, close the
        # relay connection as well.
        self.relay.close()
        self.close()

    def readable(self):
        return self.is_readable

class RelayServer(asyncore.dispatcher):
    def __init__(self, bind_address, MyAppClient_sock):
        asyncore.dispatcher.__init__(self)
        self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
        self.bind(bind_address)
        self.MyAppClient_sock = MyAppClient_sock
        print self.MyAppClient_sock
        self.listen(1)

    def handle_accept(self):
        conn, addr = self.accept()
        RelayClient(self, conn, self.MyAppClient_sock)

if __name__ == "__main__":
    # Connect to host
    # First connection stage
    connectionPhase = 1
    c = MyAppClient('host', port) # SomeServer's host and port

    asyncore.loop()

EDIT:

@samplebias I replaced my complete module with your code (not shown) and I have re-added all the bits and pieces that I need for authentication etc.

At this point I'm getting the same result, as with my own code above. What I mean is that MyApp (or Server in your code) is connected to SomeServer and passing data back and forth. Everything is fine thus far. When User (or client application) connects to localhost 8080, this code is run:

if not self.listener:
    self.listener = Listener(self.listener_addr, self)

BUT, this is not run

  # if user is attached, send data
    elif self.user:
        print 'self.user'
        self.user.send(data)

So, Server is not relaying data to User. I added print statements throughout the User class to see what is run and init is the only thing. handle_read() never runs.

Why is this?

The code is a bit hard to follow, and I'm sure there are a few bugs. For example in handle_read() you're passing MyAppClient's raw socket self.socket to RelayServer. You end up with both MyAppClient and RelayConnection working on the same socket.

Rather than attempt to suggest bug fixes to the original code I put together an example which does what your code intents and is cleaner and easier to follow. I've tested it talking to an IMAP server and it works, but omits some things for brevity (error handling, proper close() handling in all cases, etc).

• Server initiates the connection to "someserver". Once it connects it starts the Listener.
• Listener listens on port 8080 and accepts only 1 connection, creates a User, and passes it a reference to Server. Listener rejects all other client connections while User is active.
• User forwards all data to Server, and vice versa. The comments indicate where the authentication should be plugged in.

Source:

import asyncore
import socket

class User(asyncore.dispatcher_with_send):

    def __init__(self, sock, server):
        asyncore.dispatcher_with_send.__init__(self, sock)
        self.server = server

    def handle_read(self):
        data = self.recv(4096)
        # parse User auth protocol here, authenticate, set phase flag, etc.
        # if authenticated, send data to server
        if self.server:
            self.server.send(data)

    def handle_close(self):
        if self.server:
            self.server.close()
        self.close()

class Listener(asyncore.dispatcher_with_send):

    def __init__(self, listener_addr, server):
        asyncore.dispatcher_with_send.__init__(self)
        self.server = server
        self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
        self.set_reuse_addr()
        self.bind(listener_addr)
        self.listen(1)

    def handle_accept(self):
        conn, addr = self.accept()
        # this listener only accepts 1 client. while it is serving 1 client
        # it will reject all other clients.
        if not self.server.user:
            self.server.user = User(conn, self.server)
        else:
            conn.close()

class Server(asyncore.dispatcher_with_send):

    def __init__(self, server_addr, listener_addr):
        asyncore.dispatcher_with_send.__init__(self)
        self.server_addr = server_addr
        self.listener_addr = listener_addr
        self.listener = None
        self.user = None

    def start(self):
        self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
        self.connect(self.server_addr)

    def handle_error(self, *n):
        self.close()

    def handle_read(self):
        data = self.recv(4096)
        # parse SomeServer auth protocol here, set phase flag, etc.
        if not self.listener:
            self.listener = Listener(self.listener_addr, self)
        # if user is attached, send data
        elif self.user:
            self.user.send(data)

    def handle_close(self):
        if self.user:
            self.user.server = None
            self.user.close()
            self.user = None
        if self.listener:
            self.listener.close()
            self.listener = None
        self.close()
        self.start()

if __name__ == '__main__':
    app = Server(('someserver', 143), ('localhost', 8080))
    app.start()
    asyncore.loop()