Serializing Ctype Union

Is there a way to serialized ctype unions in order to send them over sockets? I’m trying to send a union over sockets to a network server but I am unable to serialize the data an

Solution 1:

If you call bytes() on your ctypes.Structure or ctypes.Union, you will get the underlying byte string that can be transmitted over a socket. On receipt, copy that byte string back into the original object.

Here's a self-contained example. The socket server is started as a thread and will send two objects to a client. The client then receives the object and interprets it:

import ctypes
import socket
import threading

# Used to indicate what type of field is in the Union.
U32 = 1
DBL = 2classMyUnion(ctypes.Union):
    _fields_ = ('u32',ctypes.c_uint32),('dbl',ctypes.c_double)

classMyStruct(ctypes.Structure):
    _pack_ = 1# define before _fields_ to have an affect.
    _fields_ = ('type',ctypes.c_int),('u',MyUnion)

defclient():
    s = socket.socket()
    s.connect(('localhost',5000))

    # Wrap the socket in a file-like object so an exact amount of bytes can be read.
    r = s.makefile('rb')

    # Read two structures from the socket.
    ex1 = MyStruct.from_buffer_copy(r.read(ctypes.sizeof(MyStruct)))
    ex2 = MyStruct.from_buffer_copy(r.read(ctypes.sizeof(MyStruct)))
    s.close()

    # display the correct Union field by type.for ex in (ex1,ex2):
        if ex.type == U32:
            print(ex.u.u32)
        else:
            print(ex.u.dbl)

defserver():
    s = socket.socket()
    s.bind(('',5000))
    s.listen(1)
    c,a = s.accept()

    # Prepare two structures
    ex1 = MyStruct()
    ex1.type = DBL
    ex1.u.dbl = 1.234
    ex2 = MyStruct()
    ex2.type = U32
    ex2.u.u32 = 1234# Send them as bytes
    c.sendall(bytes(ex1))
    c.sendall(bytes(ex2))

    c.close()
    s.close()

# spin off the server in a thread so the client can connect to it.
t = threading.Thread(target=server)
t.start()

client()

Output:

1.2341234