从一个套接字传递到另一个套接字

Question

我正在尝试写一个程序，充当中介（M）。

我只能用telnet来连接：

A需要连接到M，B也连接到M。

A通过一个套接字向M发送数据，M需要把这些数据转发给B。

B通过另一个套接字向M发送数据。

我尝试通过启动四个线程，并使用一个共享的列表来实现这个功能。

问题是，似乎没有把数据写入另一个套接字，甚至连写入都不接受。

有没有人知道更好的方法来实现这个功能，并将数据传递到另一个套接字？

我的代码：

import sys
import arduinoReadThread
import arduinoWriteThread
import socket
class ControllerClass(object):
    '''
    classdocs
    '''
    bolt = 0
    socketArray=list()

    def __init__(self):
        self.readAndParseArgv()
        self.createThreads()

    def readAndParseArgv(self):
        array = sys.argv
        print sys.argv
        if len(array) != 3:
            print "Too few arguments : ./script host:port host:port"
        else:
            for line in array:
                if ":" in line:
                    splitted = line.split(':')
                    HOST = splitted[0]
                    print HOST
                    PORT = int(splitted[1])
                    print PORT
                    s=socket.socket(socket.AF_INET, socket.SOCK_STREAM ) #create an INET, STREAMing socket
                    s.bind((HOST,PORT)) #bind to that port
                    print "test"
                    s.listen(1) #listen for user input and accept 1 connection at a time.
                    self.socketArray.append(s)

    def createThreads(self):
        print "Creating Threads"
        sharedArray1 = list()
        sharedArray2 = list()
        s1 = self.socketArray.pop()
        s2 = self.socketArray.pop()
        sT1 = arduinoWriteThread.writeThread().run(self.bolt,sharedArray1,s2)
        sT2 = arduinoReadThread.readThread().run(self.bolt,sharedArray1,s1)
        sT3 = arduinoReadThread.readThread().run(self.bolt,sharedArray2,s2)
        sT4 = arduinoWriteThread.writeThread().run(self.bolt,sharedArray2,s1)
        sT1.start()
        sT2.start()
        sT3.start()
        sT4.start()
x = ControllerClass()
x

两个线程：

写入线程：

import threading
class writeThread ( threading.Thread ):

    def run ( self,bolt,writeList,sockeToWriteTo ):
        s = sockeToWriteTo
        while(bolt == 0):
            conn, addr = s.accept()
            if len(writeList) > 0:

                socket.send(writeList.pop(0))

读取线程

import threading
    class readThread ( threading.Thread ):

    def run ( self,bolt,writeList,socketToReadFrom ):
        s = socketToReadFrom
        while(bolt == 0):
            conn, addr = s.accept()

            f = conn.rcv()
            print f
            writeList.append(f)

Answer 1

其实你并不需要用到线程来解决这个问题...

当你接受到一个新的连接时，把它加到一个列表里。当从这个列表中的某个连接收到消息时，把这条消息发送给所有其他的连接，但不要发给发送消息的那个连接。

可以使用 select 来查看哪些连接有数据发送给你。

编辑

下面是一个使用 select 的例子：

# serversocket: One server socket listening on some port, has to be non-blocking
# all_sockets : List containing all connected client sockets
while True:
    readset = [serversocket]
    readset += all_sockets

    # Wait for sockets to be ready, with a 0.1 second timeout
    read_ready = select.select(readset, None, None, 0.1)

    # If the listening socket can be read, it means it has a new connection
    if serversocket in read_ready:
        new_connection = serversocket.accept()
        new_connection.setblocking(0);  # Make socket non-blocking
        all_sockets += [new_connection]
        read_ready.remove(serversocket) # To not loop over it below

    for socket in read_ready:
        # Read data from socket
        data = socket.recv(2048)
        for s in all_sockets:
            # Do not send to self
            if s != socket:
                s.send(data)

免责声明 我其实从来没有真正使用过 Python 的 socket 函数，上面的代码是我刚刚看手册时写的。这个代码可能并不是最优的，也不一定很符合 Python 的风格。