Selecting random port on a remote host

Question

I want to select a random high port on a remote linux machine and use it for my application. On my localhost, I can bind to port 0 and get a random high port, but this does not work if I give a remote host.

The code is as follows:

host = "remote_host"

def get_open_port():
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.bind((host,0))
    s.listen(1)
    port = s.getsockname()[1]
    s.close()
    return port

Error:

Traceback (most recent call last):
  File "server.py", line 25, in <module>
    port = get_open_port()
  File "server.py", line 11, in get_open_port
    s.bind((host,0))
  File "<string>", line 1, in bind

Answer 1

Well I guess you are bit confused with the client-server communication. Before getting to the solution of your problem lets first revisit the client-server communication process. Normally it is the client who makes/initiates the connection request (simply a connection) to the server. The client makes a request to the server on a remote port which is listening for incoming connections. This remote port should be open on the server side and should be waiting for incoming connections. For eg: If you want to connect to a remote server on the remote port number 15200, then it is mandatory that you should open the port number 15200 on the server side and it should be listening for any incoming connections/requests. Also, the client will know this in advance to which remote port it should make a request for a connection!

Lets understand some more facts before getting to the one of the possible solution to your problem. First lets understand the server side.

Server side: You are trying the server to use any random port for accepting incoming connections from a client. It will surely work as you are binding port number 0 in your server code as s.bind((host,0)). When you bind the port number 0 then your server (actually the OS which is running the server script) will use any random high port number for accepting the remote connections which will be usually greater than 1023. You can test this by following code snippet. Run the following code snippet and you may notice that the server is opening random high port numbers.

import socket
host = "127.0.0.1"

def get_open_port():
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    s.bind((host,0))
    s.listen(1)
    port = s.getsockname()[1]
    s.close()
    return port

for i in range(0,5):
        print "Opening port no. %s"%get_open_port()

On executing the above code you'll shall see that a random port number is being selected by the server code to accept incoming connections every time. But it is also closing it after wards using s.close(). In my case the output was as below (You may get a different set of port numbers):

Opening port no. 60876
Opening port no. 60877
Opening port no. 60878
Opening port no. 60879
Opening port no. 60880

So, I guess now you understood the server part. Lets discuss the client side now.

Client side: As mentioned earlier that a client needs to know the remote server port to which it needs to connect. A typical client code looks as given below:

import socket
host = "127.0.0.1"
port = 60880
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host, port))

In the above code snippet this line s.connect((host, port)) you need to mention the host the remote host name or IP and port the remote port to which you want to connect to. So it means that client should know the port number in advance! As a result you have to mention the port in your client code. As I have done in my code snippet as port = 60880.

Now coming to your question: As you already noticed from above text that you have to mention the remote server's port number in client code to make a request for a connection. So, you can't expect your client to figure out itself the remote port of the server which is actually listening for incoming request. The client code can't do this by its own.

Solution:

So what if the client code can't figure out by itself the remote port number we'll make it to figure it out! ;) What we know is if you bind the port number 0 on server side then a random port number will be selected which will be greater than 1023. So, it means the random port number will always be greater than 1023. Also, the maximum value of port number is 65535. Ultimately we come to a conclusion that the random port that will used by the server will be any port number in this range 1024 - 65335. Now all you have to do is in your client code you have to use a range of port numbers to which it should make connection. Because we don't know what remote port is listening on the server side for accepting incoming requests/connection!

Sample code for plying around: I tested these code snippets using my localhost. Here is the server code. Run the server code first then run the client code. Upon executing the server code, it'll display in console/output that what is the random port number opened for accepting incoming request/connections. When a client is connected the server will display a message the Got a client connected along with the IP of the client.

#This is the server script
import socket
host = "127.0.0.1"

def get_open_port():
    mySocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    mySocket.bind((host,0))
    mySocket.listen(1)
    port = mySocket.getsockname()[1]
    print "Port opened for incoming connections %d"%port
    (clientSocket, clientAddress) = mySocket.accept()
    print "Got a client: ", clientAddress
    clientSocket.close()
    mySocket.close()

get_open_port()

Here is a client code sample that will do this crazy stuff. It will try to connect on all the ports from 1024 - 65335 and when it finds any remote port which is listening for incoming connections. It will display a message "Connected to remote port" and then close the socket and continue looking for more open ports until it reaches the last port number 65355.

#This is the client script
import socket
host = "127.0.0.1"

def startConn():
    for port in range(1024,65336):
        try:
            myClientSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            print "Trying remote port: ",port
            myClientSocket.connect((host,port))
            print "Connected to remote port: ",port
            myClientSocket.close()
        except socket.error as msg:
            myClientSocket.close()
            continue

startConn()

This is just a sample code, I am intentionally closing the sockets after a successful is established. You can do something else what you ever you prefer. I hope now it is quite clear to you regarding server-client communication.