I don't know anything about Kotlin, but given the C structure described here's a C DLL with that structure and the Python code to call it. The structures need to be derived from ctypes.Structure and the return type of the function needs to be declared via .restype and not left to the default of (usually 32-bit) integer. Casting the return value after-the-fact is too late if it was meant to be a 64-bit pointer.

test.c

#ifdef _WIN32
#   define API __declspec(dllexport)
#else
#   define API
#endif

typedef struct {
  struct {
    struct {
        int a;
    } root;
  } kotlin;
} libnative_ExportedSymbols;

libnative_ExportedSymbols g_lib = {7};

API libnative_ExportedSymbols* libnative_symbols(void) {
    return &g_lib;
}

test.py

import ctypes as ct

class Root(ct.Structure):
    _fields_ = ('a', ct.c_int),

class Kotlin(ct.Structure):
    _fields_ = ('root', Root),

class Symbols(ct.Structure):
    _fields_ = ('kotlin', Kotlin),

dll = ct.CDLL('./test')
dll.libnative_symbols.argtypes = ()
dll.libnative_symbols.restype = ct.POINTER(Symbols)

lib = dll.libnative_symbols()
print(lib.contents.kotlin.root.a)

Output:

7

Change

foo = POINTER(temp_foo)

to

foo = pointer(temp_foo)

can solve the problem.

Please see http://docs.python.org/library/ctypes.html#ctypes-pointers for more information.

You are assuming that c directly follows b which is not the case. The compiler will pad a few bytes, 2 on x86, in that structure to align c.

The proper way is to declare one-to-one mapping of your structure in ctypes:

from ctypes import *

class object_t(Structure):
    _fields_ = [
        ('a', c_uint8),
        ('b', c_uint8),
        ('c', c_uint32),
        ('d', POINTER(c_uint8)),
    ]

No you can obtain the value of any member thought this type.

C example library:

#include <stdint.h>
#include <stdlib.h>

struct object_t {
  uint8_t a;
  uint8_t b;
  uint32_t c;
  uint8_t* d;
};

static struct object_t object = {'a', 'b', 12345, NULL};

struct object_t * func1(void)
{
  return &object;
}

void func2(void(*callback)(struct object_t *))
{
  callback(&object);
}

Using it from Python:

from ctypes import *

class object_t(Structure):
    _fields_ = [
        ('a', c_uint8),
        ('b', c_uint8),
        ('c', c_uint32),
        ('d', POINTER(c_uint8)),
    ]

callback_t = CFUNCTYPE(None, POINTER(object_t))

lib = CDLL('./file.dll')

func1 = lib.func1
func1.argtypes = None
func1.restype  = POINTER(object_t)

func2 = lib.func2
func2.argtypes = [callback_t]
func2.restype   = None

ret = func1()

a = ret.contents.a
b = ret.contents.b
c = ret.contents.c
d = ret.contents.d

def mycallback(obj):
    a = obj.contents.a
    b = obj.contents.b
    c = obj.contents.c
    d = obj.contents.d

func2(callback_t(mycallback))

Well there are some mistakes in the above code.

Need to pass the pointer address as an unsigned long/int to the python module. So

void getmodelparam(long pModelParam)

//has to become

void getmodelparam(unsigned long pModelParam)

//and 

PyObject *pResult = PyObject_CallFunction(pFunc,"i", pModelParam) ;

// has to become 

PyObject *pResult = PyObject_CallFunction(pFunc,"k", pModelParam) ;

and then in the python file:

def modifymodelparam(m):
    n = ctypes.cast(m, ctypes.POINTER(someTime))
    print (n.contents.seconds)
    print (n.contents.nanoseconds)