Question

I’m trying to implement Window socket using Python.

Mostly, everything has been so far solved using ctypes.windll.ws2_32 and pywin32 lib.

However, I haven’t been able to find out how to translate the following C++ codes into Python and I wonder if anyone is kind enough to help:

LRESULT WINAPI AsyncSocketProc(
                           __in  HWND hwnd,
                           __in  UINT uMsg,
                           __in  WPARAM wParam,
                           __in  LPARAM lParam
                          )
switch(uMsg) {
    case WM_CREATE: 
        //...
    case WM_SOCKET: {# this is basically an int constant
        switch(WSAGETSELECTEVENT(lParam)){
              case FD_ACCEPT:
                  //accepting new conn
              case FD_READ:
                  //receiving data 
        }
    }
}

In the above code, I couldn’t find Python’s equivalent for WSAGETSELECTEVENT.

For the FD_ACCEPT, FD_READ, I could find them inside win32file package (of pywin32 lib)

Lastly, the reason why I’m trying to implement this Window socket programming is that the C++ version of the window socket server (above) is non-blocking for an application of mine but Python’s built-in select.select is blocking. So I’m trying to see if I can port the C++ version to Python and see if it works.

EDITED:
I would like to clarify that the socket server works as a ‘plug in’ to an existing C++ program, which doesn’t support threading.

The socket server needs to wait (indefinitely) for clients to connect so it needs to continuously listen.
So using a normal Python socket or select.select would entail a while loop (or otherwise how can it acts as a server continuously listening for events? Please correct me I’m wrong), which would block the main program.

Somehow, using the Window Socket server callback above, the main program is not blocked. And this is the main reason while I’m trying to port it to Python.

The socket server is preferably in Python because many related libs the server needs are written in Python.

Thanks a lot.

Answer 1

Have a look at the socket module instead. It already contains all the code you need to work with sockets without using the win32 API.

[EDIT] You can write multi threaded code that can handle several connections. Just accept the connection and then start a new thread, give it the connection and let it read the data in a while 1: data = conn.recv(1024) ... kind of loop.

That said, Python also has a module for just that: SocketServer

[EDIT2] You say

the socket server works as a ‘plug in’ to an existing program, which doesn’t support threading.

It’s a bit hard to help with so little information but think about it this way:

You can run the socket server loop in a new thread. This code is isolated from the rest of your app, so it doesn’t matter whether the other code uses/supports threads. This solves your “endless loop” problem.

Now this socket server loop will get connections from clients. My guess is that the clients will call methods from the rest of the app and here, things get hairy.

You need a way to synchronize these calls. In other places (like all UI frameworks), there is a single thread which runs any UI calls (drawing something, creating the UI, responding to user input).

But if I understand you correctly, then you can in fact modify the “main loop” of the existing app and let it do more things (like listening to new connections). If you can do this, then there is a way out:

Create a new thread for the socket server as described above. When the server gets a connection, spawn a new thread that talks to the client. When the client sends commands, create “work objects” (see command pattern) and put them into a queue.

In the main loop, you can look into the queue. If something is in there, pop the work objects and call it’s run() method.