ctypes.cast.

>>> import ctypes
>>> c_long_p = ctypes.POINTER(ctypes.c_long)
>>> some_long = ctypes.c_long(42)
>>> ctypes.addressof(some_long)
4300833936
>>> ctypes.cast(4300833936, c_long_p)
<__main__.LP_c_long object at 0x1005983b0>
>>> ctypes.cast(4300833936, c_long_p).contents
c_long(42)

Function pointers can use CFUNCTYPE(retval,params...) to declare C function pointers. The code below is a guess based on the description and minimal code:

test.c

#if defined(_WIN32)
#   define API __declspec(dllexport)
#else
#   define API
#endif

#include <stdlib.h>

struct instance; // forward declaration...

typedef int (*callback)(struct instance *); // so callback can be defined...

typedef struct instance { // and structure declared.
    int x;
    callback f;
} instance;

int func(instance* p) {  // Callback
    return ++p->x;
}

API instance* get_instance(void) {
    instance* p = malloc(sizeof(instance));
    p->x = 5;
    p->f = func;
    return p;
}

API void free_instance(instance* p) {
    free(p);
}

test.py

from ctypes import *

# Forward declaration...
class Instance(Structure):
    pass

# so the callback parameter pointer can be declared...
CALLBACK = CFUNCTYPE(c_int,POINTER(Instance))

# and then the fields can be defined.
Instance._fields_ = (('x',c_int),
                     ('f',CALLBACK))

dll = CDLL('./test')
dll.get_instance.argtypes = ()
dll.get_instance.restype = POINTER(Instance)
dll.free_instance.argtypes = POINTER(Instance),
dll.free_instance.restype = None

instance = dll.get_instance()
try:
    print(instance.contents.x)
    print(instance.contents.f(instance))
    print(instance.contents.f(instance))
    print(instance.contents.f(instance))
finally:
    dll.free_instance(instance)

Output:

5
6
7
8

References:

• https://docs.python.org/3/library/ctypes.html#incomplete-types
• https://docs.python.org/3/library/ctypes.html#callback-functions

It is unclear how the function returns the value, but from the name it might be returning a pointer to an internal static buffer with serial/model information, so this should work. Note I have set the .argtypes and .restype of the function for some type checking.

Test DLL:

#define EXPORT __declspec(dllexport)

long EXPORT newp_usb_get_model_serial_keys (char** ppBuffer)
{
    static char item[] = "hello, world!";
    *ppBuffer = item;
    return 1;
}

Python:

from ctypes import *

dll = CDLL('test')
dll.newp_usb_get_model_serial_keys.argtypes = [POINTER(c_char_p)]
dll.newp_usb_get_model_serial_keys.restype = c_long

p = c_char_p()
dll.newp_usb_get_model_serial_keys(byref(p))
print(p.value)

Output:

b'hello, world!'

I don't have your Format and Bool types, so with some substitutions, here's some sample DLL code:

#include <stddef.h>
__declspec(dllexport) void ProcessAndsend(char *out,        // IN
                                          char const *reqp,   // IN
                                          size_t reqLen,      // IN
                                          int *Status,       // OUT
                                          char const **reply, // OUT
                                          size_t *resLen)     // OUT
{
    *Status = 1;
    *reply = "test";
    *resLen = 5;
}

This will retrieve the output data. Just create some instances of the correct ctypes types and pass them by reference:

>>> from ctypes import *
>>> dll = CDLL('your.dll')
>>> f = dll.ProcessAndsend
>>> f.argtypes = c_char_p,c_char_p,c_size_t,POINTER(c_int),POINTER(c_char_p),POINTER(c_size_t)
>>> f.restype = None
>>> status = c_int()
>>> reply = c_char_p()
>>> size = c_size_t()
>>> f('abc','def',3,byref(status),byref(reply),byref(size))
>>> status
c_long(1)
>>> reply
c_char_p('test')
>>> size
c_ulong(5L)