精华内容
下载资源
问答
  • python调用dll文件接口

    万次阅读 2017-07-09 23:16:33
    使用python的ctypes模块可以很方便的调用windows的dll(也包括linux下的so等文件),下面将详细的讲解这个模块(以windows平台为例子),当然我假设你们已经对windows下怎么写一个DLL是没有问题的。   引入ctypes...


    转载


    Python中某些时候需要C做效率上的补充,在实际应用中,需要做部分数据的交互。使用python中的ctypes模块可以很方便的调用windows的dll(也包括linux下的so等文件),下面将详细的讲解这个模块(以windows平台为例子),当然我假设你们已经对windows下怎么写一个DLL是没有问题的。
      
    引入ctypes库 

    [python] view plain copy
    1. from ctypes import *   
    假设你已经有了一个的DLL(名字是add.dll),且该DLL有一个符合cdecl(这里强调调用约定是因为,stdcall调用约定和cdecl调用约定声明的导出函数,在使用python加载时使用的加载函数是不同的,后面会有说明)调用约定的导出函数Add。
    建立一个Python文件DllCall.py测试: 
    [python] view plain copy
    1. from ctypes import *  
    2. dll = CDLL("add.dll")  
    3. print dll.Add(1102)  
    结果:103 
      
    上面是一个简单的例子。下面简单聊一下调用流程: 
    1、加载DLL 
    上面已经说过,加载的时候要根据你将要调用的函数是符合什么调用约定的。 
    stdcall调用约定:两种加载方式 
    [python] view plain copy
    1. Objdll = ctypes.windll.LoadLibrary("dllpath")  
    2. Objdll = ctypes.WinDLL("dllpath")   
    cdecl调用约定:也有两种加载方式 
    [python] view plain copy
    1. Objdll = ctypes.cdll.LoadLibrary("dllpath")  
    2. Objdll = ctypes.CDLL("dllpath")  
    3. <span style="font-family:Microsoft YaHei;">其实windll和cdll分别是WinDLL类和CDll类的对象。</span>  

    dll函数的_stdcall 和 _cdecl, stdcall是被调用者来进行栈的处理, cdecl是调用者进行栈的处理。

    cdecl中每个调用者都要嵌入处理的代码,所以代码量会大一些。

    但为什么不都用stdcall。像printf这样的函数,事先不知道需要的栈大小,需要用cdecl来处理

    所以需要使用cdecl来调用  



    2、调用dll中的方法 
    在1中加载dll的时候会返回一个DLL对象(假设名字叫Objdll),利用该对象就可以调用dll中的方法。 
    e.g.如果dll中有个方法名字叫Add(注意如果经过stdcall声明的方法,如果不是用def文件声明的导出函数或者extern “C” 声明的话,编译器会对函数名进行修改,这个要注意,我想你们懂的。)
    调用:nRet = Objdll.Add(12, 15) 即完成一次调用。 
      
    看起来调用似乎很简单,不要只看表象,呵呵,这是因为Add这个函数太简单了,现在假设函数需要你传入一个int类型的指针(int*),可以通过库中的byref关键字来实现,假设现在调用的函数的第三个参数是个int类型的指针。
    [python] view plain copy
    1. intPara = c_int(9)  
    2. dll.sub(23102, byref(intPara))  
    3. print intPara.value  
    如果是要传入一个char缓冲区指针,和缓冲区长度,方法至少有四种: 
    [python] view plain copy
    1. # 方法1  
    2. szPara = create_string_buffer('/0'*100)  
    3. dll.PrintInfo(byref(szPara), 100);  
    4. print szPara.value  
    5.   
    6. # 方法2  
    7. sBuf = 'aaaaaaaaaabbbbbbbbbbbbbb'  
    8. pStr = c_char_p( )  
    9. pStr.value = sBuf  
    10. #pVoid = ctypes.cast( pStr, ctypes.c_void_p ).value  
    11. dll.PrintInfo(pStr, len(pStr.value))  
    12. print pStr.value  
    13.   
    14. # 方法3  
    15. strMa = "/0"*20  
    16. FunPrint  = dll.PrintInfo  
    17. FunPrint.argtypes = [c_char_p, c_int]  
    18. #FunPrint.restypes = c_void_p  
    19. nRst = FunPrint(strMa, len(strMa))  
    20. print strMa,len(strMa)  
    21.   
    22. # 方法4  
    23. pStr2 = c_char_p("/0")  
    24. print pStr2.value  
    25. #pVoid = ctypes.cast( pStr, ctypes.c_void_p ).value  
    26. dll.PrintInfo(pStr2, len(pStr.value))  
    27. print pStr2.value  
      
    3、C基本类型和ctypes中实现的类型映射表 
    ctypes数据类型          C数据类型 
    c_char                          char 
    c_short                         short 
    c_int                             int 
    c_long                          long 
    c_ulong                        unsign long 
    c_float                          float 
    c_double                      double 
    c_void_p                       void 
    对应的指针类型是在后面加上"_p",如int*是c_int_p等等。 
    在python中要实现c语言中的结构,需要用到类。 
      
    4、DLL中的函数返回一个指针。 
    虽然这不是个好的编程方法,不过这种情况的处理方法也很简单,其实返回的都是地址,把他们转换相应的python类型,再通过value属性访问。 
    [python] view plain copy
    1. pchar = dll.getbuffer()  
    2. szbuffer = c_char_p(pchar)  
    3. print szbuffer.value  
      
    5、处理C中的结构体类型 
    为什么把这个单独提出来说呢,因为这个是最麻烦也是最复杂的,在python里面申明一个类似c的结构体,要用到类,并且这个类必须继承自Structure。 
    先看一个简单的例子: 
    C里面dll的定义如下: 
    [cpp] view plain copy
    1. typedef struct _SimpleStruct  
    2. {  
    3.     int    nNo;  
    4.     float  fVirus;  
    5.     char   szBuffer[512];  
    6. } SimpleStruct, *PSimpleStruct;  
    7. typedef const SimpleStruct*  PCSimpleStruct;  
    8.   
    9. extern "C"int  __declspec(dllexport) PrintStruct(PSimpleStruct simp);  
    10. int PrintStruct(PSimpleStruct simp)  
    11. {  
    12.     printf ("nMaxNum=%f, szContent=%s", simp->fVirus, simp->szBuffer);  
    13. return simp->nNo;  
    14. }  
      
    Python的定义: 
    [python] view plain copy
    1. from ctypes import *  
    2. class SimpStruct(Structure):  
    3.     _fields_ = [ ("nNo", c_int),  
    4.               ("fVirus", c_float),  
    5.               ("szBuffer", c_char * 512)]  
    6.   
    7. dll = CDLL("AddDll.dll")  
    8. simple = SimpStruct();  
    9. simple.nNo = 16  
    10. simple.fVirus = 3.1415926  
    11. simple.szBuffer = "magicTong/0"  
    12. print dll.PrintStruct(byref(simple))  

    上面例子结构体很简单,但是如果结构体里面有指针,甚至是指向结构体的指针,处理起来会复杂很多,不过Python里面也有相应的处理方法,下面这个例子来自网上,本来想自己写个,懒得写了,能说明问题就行:
    C代码如下: 
    [cpp] view plain copy
    1. typedef struct   
    2.   
    3. {  
    4.   
    5. char words[10];  
    6.   
    7. }keywords;  
    8.   
    9.    
    10.   
    11. typedef struct   
    12.   
    13. {  
    14.   
    15. keywords *kws;  
    16.   
    17. unsigned int len;  
    18.   
    19. }outStruct;  
    20.   
    21. extern "C"int __declspec(dllexport) test(outStruct *o);  
    22.   
    23. int test(outStruct *o)  
    24.   
    25. {  
    26.   
    27. unsigned int i = 4;  
    28.   
    29. o->kws = (keywords *)malloc(sizeof(unsigned char) * 10 * i);  
    30.   
    31. strcpy(o->kws[0].words, "The First Data");  
    32.   
    33. strcpy(o->kws[1].words, "The Second Data");  
    34.   
    35.    
    36.   
    37. o->len = i;  
    38.   
    39. return 1;  
    40.   
    41. }  
    Python代码如下: 
    [python] view plain copy
    1. class keywords(Structure):  
    2.   
    3.         _fields_ = [('words', c_char *10),]  
    4.   
    5.    
    6.   
    7. class outStruct(Structure):  
    8.   
    9.         _fields_ = [('kws', POINTER(keywords)),  
    10.   
    11.                     ('len', c_int),]  
    12.   
    13. o = outStruct()  
    14.   
    15. dll.test(byref(o))  
    16.   
    17.    
    18.   
    19. print o.kws[0].words;  
    20.   
    21. print o.kws[1].words;  
    22.   
    23. print o.len  
      
    6、例子 
    说得天花乱坠,嘿嘿,还是看两个实际的例子。 
    例子1: 
    这是一个GUID生成器,其实很多第三方的python库已经有封装好的库可以调用,不过这得装了那个库才行,如果想直接调用一些API,对于python来说,也要借助一个第三方库才行,这个例子比较简单,就是用C++调用win32 API来产生GUID,然后python通过调用C++写的dll来获得这个GUID。
    C++代码如下: 
    [cpp] view plain copy
    1. extern "C"__declspec(dllexportchar* newGUID();   
    2.   
    3. char* newGUID()   
    4.   
    5. {  
    6.   
    7.      static char buf[64] = {0};  
    8.   
    9.      statc GUID guid;  
    10.   
    11.      if (S_OK == ::CoCreateGuid(&guid))   
    12.   
    13.      {  
    14.   
    15.        _snprintf(buf, sizeof(buf),  
    16.   
    17. "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",   
    18.   
    19. guid.Data1,  
    20.   
    21. guid.Data2,  
    22.   
    23. guid.Data3,  
    24.   
    25. guid.Data4[0], guid.Data4[1],  
    26.   
    27. guid.Data4[2], guid.Data4[3],  
    28.   
    29. guid.Data4[4], guid.Data4[5],  
    30.   
    31. guid.Data4[6], guid.Data4[7]  
    32.   
    33. );   
    34.   
    35.        ::MessageBox(NULL, buf, "GUID", MB_OK);   
    36.   
    37.       }  
    38.   
    39.      return (char*)buf;  
    40.   
    41. }  
    Python代码如下: 
    [python] view plain copy
    1. def CreateGUID():  
    2.   
    3.     """ 
    4.  
    5.     创建一个全局唯一标识符 
    6.  
    7.     类似:E06093E2-699A-4BF2-A325-4F1EADB50E18 
    8.  
    9.     NewVersion 
    10.  
    11.     """  
    12.   
    13.     try:  
    14.   
    15.         # dll path  
    16.   
    17.         strDllPath = sys.path[0] + str(os.sep) + "createguid.dll"  
    18.   
    19.         dll = CDLL(strDllPath)  
    20.   
    21.         b = dll.newGUID()  
    22.   
    23.         a = c_char_p(b)  
    24.   
    25.     except Exception, error:  
    26.   
    27.         print error  
    28.   
    29.         return ""  
    30.   
    31.     return a.value  
      
    例子2: 
    这个例子是调用kernel32.dll中的createprocessA函数来启动一个记事本进程 
    [python] view plain copy
    1. #  -*- coding:utf-8 -*-   
    2.   
    3. from ctypes import *   
    4.   
    5.    
    6.   
    7. # 定义_PROCESS_INFORMATION结构体  
    8.   
    9. class _PROCESS_INFORMATION(Structure):  
    10.   
    11.     _fields_ = [('hProcess', c_void_p),  
    12.   
    13.                 ('hThread', c_void_p),  
    14.   
    15.                 ('dwProcessId', c_ulong),  
    16.   
    17.                 ('dwThreadId', c_ulong)]  
    18.   
    19.    
    20.   
    21. # 定义_STARTUPINFO结构体  
    22.   
    23. class _STARTUPINFO(Structure):  
    24.   
    25.     _fields_ = [('cb',c_ulong),  
    26.   
    27.                 ('lpReserved', c_char_p),  
    28.   
    29.                 ('lpDesktop', c_char_p),  
    30.   
    31.                 ('lpTitle', c_char_p),  
    32.   
    33.                 ('dwX', c_ulong),  
    34.   
    35.                 ('dwY', c_ulong),  
    36.   
    37.                 ('dwXSize', c_ulong),  
    38.   
    39.                 ('dwYSize', c_ulong),  
    40.   
    41.                 ('dwXCountChars', c_ulong),  
    42.   
    43.                 ('dwYCountChars', c_ulong),  
    44.   
    45.                 ('dwFillAttribute', c_ulong),  
    46.   
    47.                 ('dwFlags', c_ulong),  
    48.   
    49.                 ('wShowWindow', c_ushort),  
    50.   
    51.                 ('cbReserved2', c_ushort),  
    52.   
    53.                 ('lpReserved2', c_char_p),  
    54.   
    55.                 ('hStdInput', c_ulong),  
    56.   
    57.                 ('hStdOutput', c_ulong),  
    58.   
    59.                 ('hStdError', c_ulong)]  
    60.   
    61.    
    62.   
    63. NORMAL_PRIORITY_CLASS = 0x00000020 #定义NORMAL_PRIORITY_CLASS  
    64.   
    65. kernel32 = windll.LoadLibrary("kernel32.dll")  #加载kernel32.dll  
    66.   
    67. CreateProcess = kernel32.CreateProcessA   #获得CreateProcess函数地址  
    68.   
    69. ReadProcessMemory = kernel32.ReadProcessMemory #获得ReadProcessMemory函数地址  
    70.   
    71. WriteProcessMemory = kernel32.WriteProcessMemory #获得WriteProcessMemory函数地址  
    72.   
    73. TerminateProcess = kernel32.TerminateProcess  
    74.   
    75.    
    76.   
    77. # 声明结构体  
    78.   
    79. ProcessInfo = _PROCESS_INFORMATION()  
    80.   
    81. StartupInfo = _STARTUPINFO()  
    82.   
    83. fileName = 'c:/windows/notepad.exe'       # 要进行修改的文件  
    84.   
    85. address = 0x0040103c        # 要修改的内存地址  
    86.   
    87. strbuf = c_char_p("_")        # 缓冲区地址  
    88.   
    89. bytesRead = c_ulong(0)       # 读入的字节数  
    90.   
    91. bufferSize =  len(strbuf.value)     # 缓冲区大小  
    92.   
    93.    
    94.   
    95. # 创建进程   
    96.   
    97. CreateProcess(fileName, 0000, NORMAL_PRIORITY_CLASS,00, byref(StartupInfo), byref(ProcessInfo))  
      
    展开全文
  • Python调用windows下DLL

    2015-07-03 15:01:35
    使用python的ctypes模块可以很方便的调用 windows的dll(也包括linux下的so等文件),下面将详细的讲解这个模块(以windows平台为例子),当然我假设你们已经对 windows下怎么写一个DLL是没有问题的。
  • 使用python的ctypes模块可以很方便的调用windows的dll(也包括linux下的so等文件),下面将详细的讲解这个模块(以windows平台为例子),当然我假设你们已经对windows下怎么写一个DLL是没有问题的。引入ctypes库...

    在python中某些时候需要C做效率上的补充,在实际应用中,需要做部分数据的交互。使用python中的ctypes模块可以很方便的调用windows的dll(也包括linux下的so等文件),下面将详细的讲解这个模块(以windows平台为例子),当然我假设你们已经对windows下怎么写一个DLL是没有问题的。

    引入ctypes库

    fromctypesimport*

    假设你已经有了一个的DLL(名字是add.dll),且该DLL有一个符合cdecl(这里强调调用约定是因为,stdcall调用约定和cdecl调用约定声明的导出函数,在使用python加载时使用的加载函数是不同的,后面会有说明)调用约定的导出函数Add。

    建立一个Python文件DllCall.py测试:

    fromctypesimport*

    dll = CDLL("add.dll")

    printdll.Add(1,102)

    结果:103

    上面是一个简单的例子。下面简单聊一下调用流程:

    1、加载DLL

    上面已经说过,加载的时候要根据你将要调用的函数是符合什么调用约定的。

    stdcall调用约定:两种加载方式

    Objdll = ctypes.windll.LoadLibrary("dllpath")

    Objdll = ctypes.WinDLL("dllpath")

    cdecl调用约定:也有两种加载方式

    Objdll = ctypes.cdll.LoadLibrary("dllpath")

    Objdll = ctypes.CDLL("dllpath")

    其实windll和cdll分别是WinDLL类和CDll类的对象。

    2、调用dll中的方法

    在1中加载dll的时候会返回一个DLL对象(假设名字叫Objdll),利用该对象就可以调用dll中的方法。

    e.g.如果dll中有个方法名字叫Add(注意如果经过stdcall声明的方法,如果不是用def文件声明的导出函数或者extern “C” 声明的话,编译器会对函数名进行修改,这个要注意,我想你们懂的。)

    调用:nRet = Objdll.Add(12, 15) 即完成一次调用。

    看起来调用似乎很简单,不要只看表象,呵呵,这是因为Add这个函数太简单了,现在假设函数需要你传入一个int类型的指针(int*),可以通过库中的byref关键字来实现,假设现在调用的函数的第三个参数是个int类型的指针。

    intPara = c_int(9)

    dll.sub(23,102, byref(intPara))

    printintPara.value

    如果是要传入一个char缓冲区指针,和缓冲区长度,方法至少有四种:

    # 方法1

    szPara = create_string_buffer('/0'*100)

    dll.PrintInfo(byref(szPara), 100);

    printszPara.value

    # 方法2

    sBuf = 'aaaaaaaaaabbbbbbbbbbbbbb'

    pStr = c_char_p( )

    pStr.value = sBuf

    #pVoid = ctypes.cast( pStr, ctypes.c_void_p ).value

    dll.PrintInfo(pStr, len(pStr.value))

    printpStr.value

    # 方法3

    strMa = "/0"*20

    FunPrint  = dll.PrintInfo

    FunPrint.argtypes = [c_char_p, c_int]

    #FunPrint.restypes = c_void_p

    nRst = FunPrint(strMa, len(strMa))

    printstrMa,len(strMa)

    # 方法4

    pStr2 = c_char_p("/0")

    printpStr2.value

    #pVoid = ctypes.cast( pStr, ctypes.c_void_p ).value

    dll.PrintInfo(pStr2, len(pStr.value))

    printpStr2.value

    3、C基本类型和ctypes中实现的类型映射表

    ctypes数据类型          C数据类型

    c_char                          char

    c_short                         short

    c_int                             int

    c_long                          long

    c_ulong                        unsign long

    c_float                          float

    c_double                      double

    c_void_p                       void

    对应的指针类型是在后面加上"_p",如int*是c_int_p等等。

    在python中要实现c语言中的结构,需要用到类。

    4、DLL中的函数返回一个指针。

    虽然这不是个好的编程方法,不过这种情况的处理方法也很简单,其实返回的都是地址,把他们转换相应的python类型,再通过value属性访问。

    pchar = dll.getbuffer()

    szbuffer = c_char_p(pchar)

    printszbuffer.value

    5、处理C中的结构体类型

    为什么把这个单独提出来说呢,因为这个是最麻烦也是最复杂的,在python里面申明一个类似c的结构体,要用到类,并且这个类必须继承自Structure。

    先看一个简单的例子:

    C里面dll的定义如下:

    typedefstruct_SimpleStruct

    {

    intnNo;

    floatfVirus;

    charszBuffer[512];

    } SimpleStruct, *PSimpleStruct;

    typedefconstSimpleStruct*  PCSimpleStruct;

    extern"C"int__declspec(dllexport) PrintStruct(PSimpleStruct simp);

    intPrintStruct(PSimpleStruct simp)

    {

    printf ("nMaxNum=%f, szContent=%s", simp->fVirus, simp->szBuffer);

    returnsimp->nNo;

    }

    Python的定义:

    fromctypesimport*

    classSimpStruct(Structure):

    _fields_ = [ ("nNo", c_int),

    ("fVirus", c_float),

    ("szBuffer", c_char *512)]

    dll = CDLL("AddDll.dll")

    simple = SimpStruct();

    simple.nNo = 16

    simple.fVirus = 3.1415926

    simple.szBuffer = "magicTong/0"

    printdll.PrintStruct(byref(simple))

    上面例子结构体很简单,但是如果结构体里面有指针,甚至是指向结构体的指针,处理起来会复杂很多,不过Python里面也有相应的处理方法,下面这个例子来自网上,本来想自己写个,懒得写了,能说明问题就行:

    C代码如下:

    typedefstruct

    版权声明:本文来源CSDN,感谢博主原创文章,遵循 CC 4.0 by-sa 版权协议,转载请附上原文出处链接和本声明。

    原文链接:https://blog.csdn.net/bluehawksky/article/details/39082125

    站方申明:本站部分内容来自社区用户分享,若涉及侵权,请联系站方删除。

    发表于 2020-02-13 12:58

    阅读 ( 121 )

    展开全文
  • Python调用windows下DLL详解

    千次阅读 2012-11-07 22:01:45
    使用python的ctypes模块可以很方便的调用windows的dll(也包括linux下的so等文件),下面将详细的讲解这个模块(以windows平台为例子),当然我假设你们已经对windows下怎么写一个DLL是没有问题的。 引入ctypes...

    在python中某些时候需要C做效率上的补充,在实际应用中,需要做部分数据的交互。使用python中的ctypes模块可以很方便的调用windows的dll(也包括linux下的so等文件),下面将详细的讲解这个模块(以windows平台为例子),当然我假设你们已经对windows下怎么写一个DLL是没有问题的。

    引入ctypes库


    from ctypes import *

    假设你有了一个符合cdecl(这里强调调用约定是因为,stdcall调用约定和cdecl调用约定声明的导出函数,在用python加载使用的加载函数是不同的,后面会说明)调用约定的DLL(名字是add.dll),且有一个导出函数Add。

    建立一个Python文件DllCall.py测试:

    from ctypes import *
    dll = CDLL("add.dll")
    print dll.Add(1, 102)
    结果:103

    上面是一个简单的例子。
    1、加载DLL
    上面已经说过,加载的时候要根据你将要调用的函数是符合什么调用约定的。

    stdcall调用约定:两种加载方式
    Objdll = ctypes.windll.LoadLibrary("dllpath")
    Objdll = ctypes.WinDLL("dllpath")

    cdecl调用约定:也有两种加载方式
    Objdll = ctypes.cdll.LoadLibrary("dllpath")
    Objdll = ctypes.CDLL("dllpath")

    其实windll和cdll分别是WinDLL类和CDll类的对象。


    2、调用dll中的方法

    在1中加载dll的时候会返回一个DLL对象(假设名字叫Objdll),利用该对象就可以调用dll中的方法。
    e.g.如果dll中有个方法名字叫Add(注意如果经过stdcall声明的方法,如果不是用def文件声明的导出函数的话,编译器会对函数名进行修改,这个要注意)
    调用:nRet = Objdll.Add(12, 15) 即完成一次调用。
    看起来调用似乎很简单,不要只看表象,呵呵,这是因为Add这个函数太简单了,现在假设函数需要你传入一个int类型的指针(int*),可以通过库中的byref关键字来实现,假设现在调用的函数的第三个参数是个int类型的指针。
    intPara = c_int(9)
    dll.sub(23, 102, byref(intPara))
    print intPara.value
    如果是要传入一个char缓冲区指针,和缓冲区长度,方法至少有四种:
    # char* -- 1
    szPara = create_string_buffer('\0'*100)
    dll.PrintInfo(byref(szPara), 100);
    print szPara.value
     
    # char* -- 2
    sBuf = 'aaaaaaaaaabbbbbbbbbbbbbb'
    pStr = c_char_p( )
    pStr.value = sBuf
    #pVoid = ctypes.cast( pStr, ctypes.c_void_p ).value
    dll.PrintInfo(pStr, len(pStr.value))
    print pStr.value
     
    # char* -- 3
    strMa = "\0"*20
    FunPrint = dll.PrintInfo
    FunPrint.argtypes = [c_char_p, c_int]
    #FunPrint.restypes = c_void_p
    nRst = FunPrint(strMa, len(strMa))
    print strMa,len(strMa)
     
    # char* -- 4
    pStr2 = c_char_p("\0")
    print pStr2.value
    #pVoid = ctypes.cast( pStr, ctypes.c_void_p ).value
    dll.PrintInfo(pStr2, len(pStr.value))
    print pStr2.value

    3、C基本类型和ctypes中实现的类型映射表

    ctypes数据类型 C数据类型

    c_char              char
    c_short             short
    c_int                 int
    c_long               long
    c_ulong             unsign long
    c_float               float
    c_double            double
    c_void_p             void

    对应的指针类型是在后面加上"_p",如int*是c_int_p等等。
    在python中要实现c语言中的结构,需要用到类。

    4、DLL中的函数返回一个指针。

    虽然这不是个好的编程方法,不过这种情况的处理方法也很简单,其实返回的都是地址,把他们转换相应的python类型,在通过value属性访问。
    pchar = dll.getbuffer()
    szbuffer = c_char_p(pchar)
    print szbuffer.value

    5、处理C中的结构体类型

    为什么把这个单独提出来说呢,因为这个是最麻烦也是最复杂的,在python里面申明一个类似c的结构体,要用到类,并且这个类必须继承自Structure。
    先看一个简单的例子:

    C里面dll的定义如下:
    01typedef struct _SimpleStruct
    02{
    03int nNo;
    04float fVirus;
    05char szBuffer[512];
    06} SimpleStruct, *PSimpleStruct;
    07typedef const SimpleStruct* PCSimpleStruct;
    08extern "C"int __declspec(dllexport) PrintStruct(PSimpleStruct simp);
    09int PrintStruct(PSimpleStruct simp)
    10{
    11printf ("nMaxNum=%f, szContent=%s", simp->fVirus, simp->szBuffer);
    12return simp->nNo;
    13}
    Python的定义:
    from ctypes import *
    class SimpStruct(Structure):
    _fields_ = [ ("nNo", c_int),
    ("fVirus", c_float),
    ("szBuffer", c_char * 512)]
    dll = CDLL("AddDll.dll")
    simple = SimpStruct();
    simple.nNo = 16
    simple.fVirus = 3.1415926
    simple.szBuffer = "magicTong\0"
    print dll.PrintStruct(byref(simple))
    上面例子结构体很简单,如果结构体里面有指针,甚至是指向结构体的指针,python里面也有相应的处理方法。

    下面这个例子来自网上,本来想自己写个,懒得写了,能说明问题就行:

    C代码如下:
    typedef struct
    {
    char words[10];
    }keywords;
    typedef struct
    {
    keywords *kws;
    unsigned int len;
    }outStruct;
    extern "C"int __declspec(dllexport) test(outStruct *o);
    int test(outStruct *o)
    {
    unsigned int i = 4;
    o->kws = (keywords *)malloc(sizeof(unsigned char) * 10 * i);
    strcpy(o->kws[0].words, "The First Data");
    strcpy(o->kws[1].words, "The Second Data");
    o->len = i;
    return 1;
    }

    Python代码如下:
    class keywords(Structure):
    _fields_ = [('words', c_char *10),]
    class outStruct(Structure):
    _fields_ = [('kws', POINTER(keywords)),
    ('len', c_int),]
    o = outStruct()
    dll.test(byref(o))
    print o.kws[0].words;
    print o.kws[1].words;
    print o.len

    6、例子

    说得天花乱坠,嘿嘿,还是看两个实际的例子。

    例子一:

    这是一个GUID生成器,其实很多第三方的python库已经有封装好的库可以调用,不过这得装了那个库才行,如果想直接调用一些API,对于python来说,也要借助一个第三方库才行,这个例子比较简单,就是用C++调用win32 API来产生GUID,然后python通过调用c++写的dll来获得这个GUID

    C++代码如下:
    extern "C"__declspec(dllexport) char* newGUID();
    char* newGUID()
    {
    static char buf[64] = {0};
    statc GUID guid;
    if (S_OK == ::CoCreateGuid(&guid))
    {
    // "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X"
    _snprintf(buf, sizeof(buf),
    "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",
    guid.Data1,
    guid.Data2,
    guid.Data3,
    guid.Data4[0], guid.Data4[1],
    guid.Data4[2], guid.Data4[3],
    guid.Data4[4], guid.Data4[5],
    guid.Data4[6], guid.Data4[7]
    );
    ::MessageBox(NULL, buf, "GUID", MB_OK);
    }
    return (char*)buf;
    }

    Python代码如下:
    def CreateGUID():
    """
    创建一个全局唯一标识符
    类似:E06093E2-699A-4BF2-A325-4F1EADB50E18
    NewVersion
    """
    try:
    # dll path
        strDllPath = sys.path[0] + str(os.sep) + "createguid.dll"
        dll = CDLL(strDllPath)
        b = dll.newGUID()
        a = c_char_p(b)
    except Exception, error:
        print error
    return ""
    return a.value

    例子二:

    这个例子是调用kernel32.dll中的createprocessA函数来启动一个记事本进程。
    # -*- coding:utf-8 -*-
    from ctypes import *
    # 定义_PROCESS_INFORMATION结构体
    class _PROCESS_INFORMATION(Structure):
    _fields_ = [('hProcess', c_void_p),
    ('hThread', c_void_p),
    ('dwProcessId', c_ulong),
    ('dwThreadId', c_ulong)]
    # 定义_STARTUPINFO结构体
    class _STARTUPINFO(Structure):
    _fields_ = [('cb',c_ulong),
    ('lpReserved', c_char_p),
    ('lpDesktop', c_char_p),
    ('lpTitle', c_char_p),
    ('dwX', c_ulong),
    ('dwY', c_ulong),
    ('dwXSize', c_ulong),
    ('dwYSize', c_ulong),
    ('dwXCountChars', c_ulong),
    ('dwYCountChars', c_ulong),
    ('dwFillAttribute', c_ulong),
    ('dwFlags', c_ulong),
    ('wShowWindow', c_ushort),
    ('cbReserved2', c_ushort),
    ('lpReserved2', c_char_p),
    ('hStdInput', c_ulong),
    ('hStdOutput', c_ulong),
    ('hStdError', c_ulong)]
     
    NORMAL_PRIORITY_CLASS = 0x00000020 # 定义NORMAL_PRIORITY_CLASS
    kernel32 = windll.LoadLibrary("kernel32.dll") # 加载kernel32.dll
    CreateProcess = kernel32.CreateProcessA # 获得CreateProcess函数地址
    ReadProcessMemory = kernel32.ReadProcessMemory # 获得ReadProcessMemory函数地址
    WriteProcessMemory = kernel32.WriteProcessMemory # 获得WriteProcessMemory函数地址
    TerminateProcess = kernel32.TerminateProcess
    # 声明结构体
    ProcessInfo = _PROCESS_INFORMATION()
    StartupInfo = _STARTUPINFO()
    fileName = 'c:/windows/notepad.exe' # 要进行修改的文件
    address = 0x0040103c # 要修改的内存地址
    strbuf = c_char_p("_") # 缓冲区地址
    bytesRead = c_ulong(0) # 读入的字节数
    bufferSize = len(strbuf.value) # 缓冲区大小
    # 创建进程
    CreateProcess(fileName, 0, 0, 0, 0, NORMAL_PRIORITY_CLASS,0, 0, byref(StartupInfo), byref(ProcessInfo))

    转自:http://www.52sky.org/73004.html
    展开全文
  • 使用python的ctypes模块可以很方便的调用windows的dll(也包括linux下的so等文件),下面将详细的讲解这个模块(以windows平台为例子),当然我假设你们已经对windows下怎么写一个DLL是没有问题的。 引入c...

    Python调用windows下DLL详解 - ctypes库的使用

    在python中某些时候需要C做效率上的补充,在实际应用中,需要做部分数据的交互。使用python中的ctypes模块可以很方便的调用windows的dll(也包括linux下的so等文件),下面将详细的讲解这个模块(以windows平台为例子),当然我假设你们已经对windows下怎么写一个DLL是没有问题的。
      
    引入ctypes库 

    1. from ctypes import *   

    假设你已经有了一个的DLL(名字是add.dll),且该DLL有一个符合cdecl(这里强调调用约定是因为,stdcall调用约定和cdecl调用约定声明的导出函数,在使用python加载时使用的加载函数是不同的,后面会有说明)调用约定的导出函数Add。
    建立一个Python文件DllCall.py测试: 

     

    1. from ctypes import *  
    2. dll = CDLL("add.dll")  
    3. print dll.Add(1, 102)  

    结果:103 
      
    上面是一个简单的例子。下面简单聊一下调用流程: 
    1、加载DLL 
    上面已经说过,加载的时候要根据你将要调用的函数是符合什么调用约定的。 
    stdcall调用约定:两种加载方式 

     

    1. Objdll = ctypes.windll.LoadLibrary("dllpath")  
    2. Objdll = ctypes.WinDLL("dllpath")   

    cdecl调用约定:也有两种加载方式 

     

    1. Objdll = ctypes.cdll.LoadLibrary("dllpath")  
    2. Objdll = ctypes.CDLL("dllpath")  
    3. /*其实windll和cdll分别是WinDLL类和CDll类的对象。*/  

      
    2、调用dll中的方法 
    在1中加载dll的时候会返回一个DLL对象(假设名字叫Objdll),利用该对象就可以调用dll中的方法。 
    e.g.如果dll中有个方法名字叫Add(注意如果经过stdcall声明的方法,如果不是用def文件声明的导出函数或者extern “C” 声明的话,编译器会对函数名进行修改,这个要注意,我想你们懂的。)
    调用:nRet = Objdll.Add(12, 15) 即完成一次调用。 
      
    看起来调用似乎很简单,不要只看表象,呵呵,这是因为Add这个函数太简单了,现在假设函数需要你传入一个int类型的指针(int*),可以通过库中的byref关键字来实现,假设现在调用的函数的第三个参数是个int类型的指针。

     

    1. intPara = c_int(9)  
    2. dll.sub(23, 102, byref(intPara))  
    3. print intPara.value  

    如果是要传入一个char缓冲区指针,和缓冲区长度,方法至少有四种: 

     

    1. # 方法1  
    2. szPara = create_string_buffer('/0'*100)  
    3. dll.PrintInfo(byref(szPara), 100);  
    4. print szPara.value  
    5.   
    6. # 方法2  
    7. sBuf = 'aaaaaaaaaabbbbbbbbbbbbbb'  
    8. pStr = c_char_p( )  
    9. pStr.value = sBuf  
    10. #pVoid = ctypes.cast( pStr, ctypes.c_void_p ).value  
    11. dll.PrintInfo(pStr, len(pStr.value))  
    12. print pStr.value  
    13.   
    14. # 方法3  
    15. strMa = "/0"*20  
    16. FunPrint  = dll.PrintInfo  
    17. FunPrint.argtypes = [c_char_p, c_int]  
    18. #FunPrint.restypes = c_void_p  
    19. nRst = FunPrint(strMa, len(strMa))  
    20. print strMa,len(strMa)  
    21.   
    22. # 方法4  
    23. pStr2 = c_char_p("/0")  
    24. print pStr2.value  
    25. #pVoid = ctypes.cast( pStr, ctypes.c_void_p ).value  
    26. dll.PrintInfo(pStr2, len(pStr.value))  
    27. print pStr2.value  

      
    3、C基本类型和ctypes中实现的类型映射表 
    ctypes数据类型          C数据类型 
    c_char                          char 
    c_short                         short 
    c_int                             int 
    c_long                          long 
    c_ulong                        unsign long 
    c_float                          float 
    c_double                      double 
    c_void_p                       void 
    对应的指针类型是在后面加上"_p",如int*是c_int_p等等。 
    在python中要实现c语言中的结构,需要用到类。 
      
    4、DLL中的函数返回一个指针。 
    虽然这不是个好的编程方法,不过这种情况的处理方法也很简单,其实返回的都是地址,把他们转换相应的python类型,再通过value属性访问。 

     

    1. pchar = dll.getbuffer()  
    2. szbuffer = c_char_p(pchar)  
    3. print szbuffer.value  

      
    5、处理C中的结构体类型 
    为什么把这个单独提出来说呢,因为这个是最麻烦也是最复杂的,在python里面申明一个类似c的结构体,要用到类,并且这个类必须继承自Structure。 
    先看一个简单的例子: 
    C里面dll的定义如下: 

     

    1. typedef struct _SimpleStruct  
    2. {  
    3.     int    nNo;  
    4.     float  fVirus;  
    5.     char   szBuffer[512];  
    6. } SimpleStruct, *PSimpleStruct;  
    7. typedef const SimpleStruct*  PCSimpleStruct;  
    8.   
    9. extern "C"int  __declspec(dllexport) PrintStruct(PSimpleStruct simp);  
    10. int PrintStruct(PSimpleStruct simp)  
    11. {  
    12.     printf ("nMaxNum=%f, szContent=%s", simp->fVirus, simp->szBuffer);  
    13. return simp->nNo;  
    14. }  

      
    Python的定义: 

     

    1. from ctypes import *  
    2. class SimpStruct(Structure):  
    3.     _fields_ = [ ("nNo", c_int),  
    4.               ("fVirus", c_float),  
    5.               ("szBuffer", c_char * 512)]  
    6.   
    7. dll = CDLL("AddDll.dll")  
    8. simple = SimpStruct();  
    9. simple.nNo = 16  
    10. simple.fVirus = 3.1415926  
    11. simple.szBuffer = "magicTong/0"  
    12. print dll.PrintStruct(byref(simple))  


    上面例子结构体很简单,但是如果结构体里面有指针,甚至是指向结构体的指针,处理起来会复杂很多,不过Python里面也有相应的处理方法,下面这个例子来自网上,本来想自己写个,懒得写了,能说明问题就行:
    C代码如下: 

     

    1. typedef struct   
    2.   
    3. {  
    4.   
    5. char words[10];  
    6.   
    7. }keywords;  
    8.   
    9.    
    10.   
    11. typedef struct   
    12.   
    13. {  
    14.   
    15. keywords *kws;  
    16.   
    17. unsigned int len;  
    18.   
    19. }outStruct;  
    20.   
    21. extern "C"int __declspec(dllexport) test(outStruct *o);  
    22.   
    23. int test(outStruct *o)  
    24.   
    25. {  
    26.   
    27. unsigned int i = 4;  
    28.   
    29. o->kws = (keywords *)malloc(sizeof(unsigned char) * 10 * i);  
    30.   
    31. strcpy(o->kws[0].words, "The First Data");  
    32.   
    33. strcpy(o->kws[1].words, "The Second Data");  
    34.   
    35.    
    36.   
    37. o->len = i;  
    38.   
    39. return 1;  
    40.   
    41. }  

    Python代码如下: 

    1. class keywords(Structure):  
    2.   
    3.         _fields_ = [('words', c_char *10),]  
    4.   
    5.    
    6.   
    7. class outStruct(Structure):  
    8.   
    9.         _fields_ = [('kws', POINTER(keywords)),  
    10.   
    11.                     ('len', c_int),]  
    12.   
    13. o = outStruct()  
    14.   
    15. dll.test(byref(o))  
    16.   
    17.    
    18.   
    19. print o.kws[0].words;  
    20.   
    21. print o.kws[1].words;  
    22.   
    23. print o.len  

      
    6、例子 
    说得天花乱坠,嘿嘿,还是看两个实际的例子。 
    例子1: 
    这是一个GUID生成器,其实很多第三方的python库已经有封装好的库可以调用,不过这得装了那个库才行,如果想直接调用一些API,对于python来说,也要借助一个第三方库才行,这个例子比较简单,就是用C++调用win32 API来产生GUID,然后python通过调用C++写的dll来获得这个GUID。
    C++代码如下: 

     

    1. extern "C"__declspec(dllexport) char* newGUID();   
    2.   
    3. char* newGUID()   
    4.   
    5. {  
    6.   
    7.      static char buf[64] = {0};  
    8.   
    9.      statc GUID guid;  
    10.   
    11.      if (S_OK == ::CoCreateGuid(&guid))   
    12.   
    13.      {  
    14.   
    15.        _snprintf(buf, sizeof(buf),  
    16.   
    17. "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",   
    18.   
    19. guid.Data1,  
    20.   
    21. guid.Data2,  
    22.   
    23. guid.Data3,  
    24.   
    25. guid.Data4[0], guid.Data4[1],  
    26.   
    27. guid.Data4[2], guid.Data4[3],  
    28.   
    29. guid.Data4[4], guid.Data4[5],  
    30.   
    31. guid.Data4[6], guid.Data4[7]  
    32.   
    33. );   
    34.   
    35.        ::MessageBox(NULL, buf, "GUID", MB_OK);   
    36.   
    37.       }  
    38.   
    39.      return (char*)buf;  
    40.   
    41. }  

    Python代码如下: 

     

    1. def CreateGUID():  
    2.   
    3.     """ 
    4.  
    5.     创建一个全局唯一标识符 
    6.  
    7.     类似:E06093E2-699A-4BF2-A325-4F1EADB50E18 
    8.  
    9.     NewVersion 
    10.  
    11.     """  
    12.   
    13.     try:  
    14.   
    15.         # dll path  
    16.   
    17.         strDllPath = sys.path[0] + str(os.sep) + "createguid.dll"  
    18.   
    19.         dll = CDLL(strDllPath)  
    20.   
    21.         b = dll.newGUID()  
    22.   
    23.         a = c_char_p(b)  
    24.   
    25.     except Exception, error:  
    26.   
    27.         print error  
    28.   
    29.         return ""  
    30.   
    31.     return a.value  

      
    例子2: 
    这个例子是调用kernel32.dll中的createprocessA函数来启动一个记事本进程 

     

    1. #  -*- coding:utf-8 -*-   
    2.   
    3. from ctypes import *   
    4.   
    5.    
    6.   
    7. # 定义_PROCESS_INFORMATION结构体  
    8.   
    9. class _PROCESS_INFORMATION(Structure):  
    10.   
    11.     _fields_ = [('hProcess', c_void_p),  
    12.   
    13.                 ('hThread', c_void_p),  
    14.   
    15.                 ('dwProcessId', c_ulong),  
    16.   
    17.                 ('dwThreadId', c_ulong)]  
    18.   
    19.    
    20.   
    21. # 定义_STARTUPINFO结构体  
    22.   
    23. class _STARTUPINFO(Structure):  
    24.   
    25.     _fields_ = [('cb',c_ulong),  
    26.   
    27.                 ('lpReserved', c_char_p),  
    28.   
    29.                 ('lpDesktop', c_char_p),  
    30.   
    31.                 ('lpTitle', c_char_p),  
    32.   
    33.                 ('dwX', c_ulong),  
    34.   
    35.                 ('dwY', c_ulong),  
    36.   
    37.                 ('dwXSize', c_ulong),  
    38.   
    39.                 ('dwYSize', c_ulong),  
    40.   
    41.                 ('dwXCountChars', c_ulong),  
    42.   
    43.                 ('dwYCountChars', c_ulong),  
    44.   
    45.                 ('dwFillAttribute', c_ulong),  
    46.   
    47.                 ('dwFlags', c_ulong),  
    48.   
    49.                 ('wShowWindow', c_ushort),  
    50.   
    51.                 ('cbReserved2', c_ushort),  
    52.   
    53.                 ('lpReserved2', c_char_p),  
    54.   
    55.                 ('hStdInput', c_ulong),  
    56.   
    57.                 ('hStdOutput', c_ulong),  
    58.   
    59.                 ('hStdError', c_ulong)]  
    60.   
    61.    
    62.   
    63. NORMAL_PRIORITY_CLASS = 0x00000020 #定义NORMAL_PRIORITY_CLASS  
    64.   
    65. kernel32 = windll.LoadLibrary("kernel32.dll")  #加载kernel32.dll  
    66.   
    67. CreateProcess = kernel32.CreateProcessA   #获得CreateProcess函数地址  
    68.   
    69. ReadProcessMemory = kernel32.ReadProcessMemory #获得ReadProcessMemory函数地址  
    70.   
    71. WriteProcessMemory = kernel32.WriteProcessMemory #获得WriteProcessMemory函数地址  
    72.   
    73. TerminateProcess = kernel32.TerminateProcess  
    74.   
    75.    
    76.   
    77. # 声明结构体  
    78.   
    79. ProcessInfo = _PROCESS_INFORMATION()  
    80.   
    81. StartupInfo = _STARTUPINFO()  
    82.   
    83. fileName = 'c:/windows/notepad.exe'       # 要进行修改的文件  
    84.   
    85. address = 0x0040103c        # 要修改的内存地址  
    86.   
    87. strbuf = c_char_p("_")        # 缓冲区地址  
    88.   
    89. bytesRead = c_ulong(0)       # 读入的字节数  
    90.   
    91. bufferSize =  len(strbuf.value)     # 缓冲区大小  
    92.   
    93.    
    94.   
    95. # 创建进程   
    96.   
    97. CreateProcess(fileName, 0, 0, 0, 0, NORMAL_PRIORITY_CLASS,0, 0, byref(StartupInfo), byref(ProcessInfo))  
    展开全文
  • 使用python的ctypes模块可以很方便的调用windows的dll(也包括linux下的so等文件),下面将详细的讲解这个模块(以windows平台为例子),当然我假设你们已经对windows下怎么写一个DLL是没有问题的。 引入c...
  • 使用python的ctypes模块可以很方便的调用windows的dll(也包括linux下的so等文件),下面将详细的讲解这个模块(以windows平台为例子),当然我假设你们已经对windows下怎么写一个DLL是没有问题的。引入ctypes库fr
  • lua模块分为lua写的模块和c写的模块,对于c写的模块,C模块在使用以前必须首先加载并连接,在大多数系统最容易的实现方式是通过动态连接库机制,所以lua调用c,实际就是调用c程序打包成的so(Linux)和dll...
  • 通过此文,你会了解到怎么创建一个内核模块,并且加载到Linux内核。然后修改这个内核模块,以便在/proc文件系统创建一个条目。开发内核模块的优势就是,这是一个与内核交互的相对而言比较容易的方法,因为可以让...
  • linux 编译so

    2014-06-21 14:27:00
    开发通常需要模块化设计,因此通常独立的功能会在单独的模块实现,在widnows下通常实现为dll,而在linux下则封装成so库,我们来看一下在ubuntu下怎么调用so库。以下代码与操作在ubuntu12.04上实现。首先编写一个...
  • Linux 系统,也同样面临和Window一样的问题,如何控制动态库的多个版本问题。... 同样Linux操作系统,也有同样的问题,那么它是怎么解决的呢?Linux 为解决这个问题,引入了一套机制,如果遵守这个机制来做,就
  • Linux下调用so库

    2014-07-24 16:10:54
    开发通常需要模块化设计,因此通常独立的功能会在单独的模块实现,在widnows下通常实现为dll,而在linux下则封装成so库,我们来看一下在ubuntu下怎么调用so库。以下代码与操作在ubuntu12.04上实现。 首先编写...
  • 问题描述: Java项目,做中间件的,之前是在Linux系统下开发,用JNI调用内核部提供的.so文件,但是现在又要Windows系统下测试运行情况,所以提出了题目的问题:怎么在Windows下使用eclipse java程序调用.so文件?...
  • 习惯在linux中写c程序后对于使用Windows的VS这个IDE怎么怎么觉得傻逼。使用strcpy这个函数会给我报不安全,然后就得去更改项目属性上的各个参数。除此之外,VS不同版本编译出来的DLL似乎还不能相互识别。怎么用...
  • 在看skynet遇到类似require(“skynet.core”)或者require "skynet.core"这样写的,对于这个中间有.的包名,如果C库写的,那么这个文件的命名应该是怎么样的呢...(具体怎么将main.c编译成lua调用dll,可以查看h...
  • 在C++里面调用C++写的dll的函数指针那是在容易不过了。使用C#就稍微麻烦点了!那怎么掉呢?通过上面的第一篇文章我们知道应该使用委托 delegate。如果再高级点,定义一个函数指针结构(有点像linux的内核),也同样...
  • windows下的C语言编程,需要对一段第三方dll中的函数进行超时控制,参考了很多种技术都没实现,请问该如何解决。 先说说我想到的东西: 1.的alarm,这玩意儿在Linux下有效,在Windows无法使用,即使我用的MinGW...
  • 动态链接库使用c++类的方法

    千次阅读 2008-01-02 13:01:00
    以前的关于动态链接库的写法多是直接采用...前两个方法是在linux下直接使用普通函数调用的方法来实现的。后边的是在vc++使用宏来对入口点动态调整输入输出__declspec(dllimport)和__declspec(dllexport)  方法1:
  • Android JNI 入门

    2015-04-17 15:50:33
    Linux ,MacJava最后调用的就是.so的文件,在Window就是.dll文件。 那么Java到C怎么对应起来?调用Java的哪个方法就是C的哪个方法呢?通过在Java类声明native的方法就开始了。 新建一个
  • C语言插件开发模式

    2020-12-22 21:19:05
    其实是将一个功能做成一个动态库,在window中叫dll,在Unix/Linux中叫做so。通过配置在运行的时候,在运行的时候,通过一些特殊的函数对dll或者so进行操作。找到函数的地址,调用函数。在使用函数的时候找函数,不是...

空空如也

空空如也

1 2 3
收藏数 48
精华内容 19
关键字:

linux中怎么调用dll

linux 订阅