Fix Resource functions issues

.travis.yml

@@ -8,9 +8,10 @@ python:
 
 env:
   - BITS=32
+    SKIP_WINE_KNOWN_FAILURES=1
 
 # The pywin32-219 installers for python 2.6 64bit are missing files.
-# 64-bit for 2.7, 3.3 and 3.4 are tested with appveyor.
+# 64-bit for 2.7, 3.5 and 3.6 are tested with appveyor.
 
 before_install:
   - sudo add-apt-repository ppa:ubuntu-wine/ppa -y

win32ctypes/core/__init__.py

@@ -7,16 +7,16 @@
 #
 from __future__ import absolute_import
 
+__all__ = ['_kernel32', '_advapi32', '_winerrors', '_common']
+
+from . import _winerrors
+
 try:
     import cffi
 except ImportError:
-    from win32ctypes.core.ctypes import _advapi32, _common, _kernel32
+    from .ctypes import _advapi32, _common, _kernel32
     _backend = 'ctypes'
 else:
-    from win32ctypes.core.cffi import _advapi32, _common, _kernel32
+    from .cffi import _advapi32, _common, _kernel32
     del cffi
     _backend = 'cffi'
-
-from win32ctypes.core import _winerrors
-
-__all__ = ['_kernel32', '_advapi32', '_winerrors', '_common']

win32ctypes/core/cffi/_kernel32.py

@@ -8,7 +8,7 @@
 from __future__ import absolute_import
 
 from ._util import (
-    ffi, check_null, check_zero, HMODULE, PVOID, RESOURCE, resource)
+    ffi, check_null, check_zero, check_false, HMODULE, PVOID, RESOURCE, resource)
 
 # TODO: retrieve this value using ffi
 MAX_PATH = 260
@@ -95,67 +95,83 @@ def _GetTickCount():
 def _LoadLibraryEx(lpFilename, hFile, dwFlags):
     result = check_null(
         kernel32.LoadLibraryExW(
-            unicode(lpFilename), ffi.NULL, dwFlags))
+            unicode(lpFilename), ffi.NULL, dwFlags),
+        function_name='LoadLibraryEx')
     return HMODULE(result)
 
 
 def _FreeLibrary(hModule):
-    check_zero(kernel32.FreeLibrary(PVOID(hModule)))
+    check_false(
+        kernel32.FreeLibrary(PVOID(hModule)),
+        function_name='FreeLibrary')
 
 
 def _EnumResourceTypes(hModule, lpEnumFunc, lParam):
     callback = ffi.callback('ENUMRESTYPEPROC', lpEnumFunc)
-    check_zero(
-        kernel32.EnumResourceTypesW(PVOID(hModule), callback, lParam))
+    check_false(
+        kernel32.EnumResourceTypesW(PVOID(hModule), callback, lParam),
+        function_name='EnumResourceTypes')
 
 
 def _EnumResourceNames(hModule, lpszType, lpEnumFunc, lParam):
     callback = ffi.callback('ENUMRESNAMEPROC', lpEnumFunc)
-    check_zero(
+    check_false(
         kernel32.EnumResourceNamesW(
-            PVOID(hModule), RESOURCE(lpszType), callback, lParam))
+            PVOID(hModule), RESOURCE(lpszType), callback, lParam),
+        function_name='EnumResourceNames')
 
 
 def _EnumResourceLanguages(hModule, lpType, lpName, lpEnumFunc, lParam):
     callback = ffi.callback('ENUMRESLANGPROC', lpEnumFunc)
-    check_zero(
+    check_false(
         kernel32.EnumResourceLanguagesW(
             PVOID(hModule), RESOURCE(lpType),
-            RESOURCE(lpName), callback, lParam))
+            RESOURCE(lpName), callback, lParam),
+        function_name='EnumResourceLanguages')
 
 
 def _FindResourceEx(hModule, lpType, lpName, wLanguage):
     return check_null(
         kernel32.FindResourceExW(
-            PVOID(hModule), RESOURCE(lpType), RESOURCE(lpName), wLanguage))
+            PVOID(hModule), RESOURCE(lpType), RESOURCE(lpName), wLanguage),
+        function_name='FindResourceEx')
 
 
 def _SizeofResource(hModule, hResInfo):
-    return check_zero(kernel32.SizeofResource(PVOID(hModule), hResInfo))
+    return check_zero(
+        kernel32.SizeofResource(PVOID(hModule), hResInfo),
+        function_name='SizeofResource')
 
 
 def _LoadResource(hModule, hResInfo):
-    return check_null(kernel32.LoadResource(PVOID(hModule), hResInfo))
+    return check_null(
+        kernel32.LoadResource(PVOID(hModule), hResInfo),
+        function_name='LoadResource')
 
 
 def _LockResource(hResData):
-    return check_null(kernel32.LockResource(hResData))
+    return check_null(
+        kernel32.LockResource(hResData),
+        function_name='LockResource')
 
 
 def _BeginUpdateResource(pFileName, bDeleteExistingResources):
-    return check_null(
-        kernel32.BeginUpdateResourceW(unicode(pFileName),
-                                      bDeleteExistingResources))
+    result = check_null(
+        kernel32.BeginUpdateResourceW(
+            unicode(pFileName), bDeleteExistingResources))
+    return HMODULE(result)
 
 
 def _EndUpdateResource(hUpdate, fDiscard):
-    check_zero(kernel32.EndUpdateResourceW(PVOID(hUpdate), fDiscard))
-
-
-def _UpdateResource(hUpdate, lpType, lpName, wLanguage, lpData, cbData):
-    return check_null(
-        kernel32.UpdateResourceW(PVOID(hUpdate), unicode(lpType),
-                                 unicode(lpName), wLanguage, PVOID(lpData),
-                                 cbData))
-
-
+    check_false(
+        kernel32.EndUpdateResourceW(PVOID(hUpdate), fDiscard),
+        function_name='EndUpdateResource')
+
+
+def _UpdateResource(hUpdate, lpType, lpName, wLanguage, cData, cbData):
+    lpData = ffi.from_buffer(cData)
+    check_false(
+        kernel32.UpdateResourceW(
+            PVOID(hUpdate), RESOURCE(lpType), RESOURCE(lpName),
+            wLanguage, PVOID(lpData), cbData),
+        function_name='UpdateResource')

win32ctypes/core/cffi/_util.py

@@ -53,9 +53,27 @@ def resource(lpRESOURCEID):
 
 
 class ErrorWhen(object):
+    """ Callable factory for raising errors when calling cffi functions.
 
-    def __init__(self, check):
+    """
+
+    def __init__(self, check, raise_on_zero=True):
+        """ Constructor
+
+        Parameters
+        ----------
+        check :
+            The return value that designates that an error has taken place.
+
+        raise_on_zero : bool
+            When set any error will be raised. When false the winerror
+            is checked and only non-zero win errors are raised. Currently
+            this parameters is used to workaround issues with the win32
+            implementation in ``wine``.
+
+        """
         self._check = check
+        self._raise_on_zero = raise_on_zero
 
     def __call__(self, value, function_name=''):
         if value == self._check:
@@ -72,5 +90,7 @@ def _raise_error(self, function_name=''):
         exception.function = function_name
         raise exception
 
+
 check_null = ErrorWhen(ffi.NULL)
 check_zero = ErrorWhen(0)
+check_false = ErrorWhen(False)

win32ctypes/core/ctypes/_common.py

@@ -9,7 +9,10 @@
 
 import ctypes
 import sys
-from ctypes import pythonapi, POINTER, c_void_p, py_object, c_char_p, cast
+from ctypes import (
+    pythonapi, POINTER, c_void_p, py_object, c_char_p, c_int, c_long, c_int64,
+    c_longlong)
+from ctypes import cast  # noqa imported here for convenience
 from ctypes.wintypes import BYTE
 
 from win32ctypes.core.compat import PY3
@@ -18,12 +21,12 @@
 PPy_UNICODE = c_void_p
 LPBYTE = POINTER(BYTE)
 is_64bits = sys.maxsize > 2**32
-Py_ssize_t = ctypes.c_int64 if is_64bits else ctypes.c_int
+Py_ssize_t = c_int64 if is_64bits else c_int
 
-if ctypes.sizeof(ctypes.c_long) == ctypes.sizeof(ctypes.c_void_p):
-    LONG_PTR = ctypes.c_long
-elif ctypes.sizeof(ctypes.c_longlong) == ctypes.sizeof(ctypes.c_void_p):
-    LONG_PTR = ctypes.c_longlong
+if ctypes.sizeof(c_long) == ctypes.sizeof(c_void_p):
+    LONG_PTR = c_long
+elif ctypes.sizeof(c_longlong) == ctypes.sizeof(c_void_p):
+    LONG_PTR = c_longlong
 
 if PY3:
     _PyBytes_FromStringAndSize = function_factory(

win32ctypes/core/ctypes/_kernel32.py

@@ -13,7 +13,7 @@
     HGLOBAL, LPVOID, UINT, LPWSTR, MAX_PATH)
 
 from ._common import LONG_PTR, IS_INTRESOURCE
-from ._util import check_null, check_zero, function_factory
+from ._util import check_null, check_zero, check_false, function_factory
 
 _ENUMRESTYPEPROC = ctypes.WINFUNCTYPE(BOOL, HMODULE, LPVOID, LONG_PTR)
 _ENUMRESNAMEPROC = ctypes.WINFUNCTYPE(BOOL, HMODULE, LPVOID, LPVOID, LONG_PTR)
@@ -64,8 +64,10 @@ def wrapped(handle, type_, name, language, param):
 
     return _ENUMRESLANGPROC(wrapped)
 
+
 _GetACP = function_factory(kernel32.GetACP, None, UINT)
 
+
 _LoadLibraryEx = function_factory(
     kernel32.LoadLibraryExW,
     [LPCWSTR, HANDLE, DWORD],
@@ -75,19 +77,19 @@ def wrapped(handle, type_, name, language, param):
     kernel32.FreeLibrary,
     [HMODULE],
     BOOL,
-    check_zero)
+    check_false)
 
 _EnumResourceTypes = function_factory(
     kernel32.EnumResourceTypesW,
     [HMODULE, _ENUMRESTYPEPROC, LONG_PTR],
     BOOL,
-    check_zero)
+    check_false)
 
 _LoadResource = function_factory(
     kernel32.LoadResource,
     [HMODULE, HRSRC],
     HGLOBAL,
-    check_zero)
+    check_null)
 
 _LockResource = function_factory(
     kernel32.LockResource,
@@ -105,13 +107,13 @@ def wrapped(handle, type_, name, language, param):
     kernel32.EnumResourceNamesW,
     [HMODULE, LPCWSTR, _ENUMRESNAMEPROC, LONG_PTR],
     BOOL,
-    check_zero)
+    check_false)
 
 _BaseEnumResourceLanguages = function_factory(
     kernel32.EnumResourceLanguagesW,
     [HMODULE, LPCWSTR, LPCWSTR, _ENUMRESLANGPROC, LONG_PTR],
     BOOL,
-    check_zero)
+    check_false)
 
 _BaseFindResourceEx = function_factory(
     kernel32.FindResourceExW,
@@ -134,13 +136,13 @@ def wrapped(handle, type_, name, language, param):
     kernel32.EndUpdateResourceW,
     [HANDLE, BOOL],
     BOOL,
-    check_zero)
+    check_false)
 
 _BaseUpdateResource = function_factory(
     kernel32.UpdateResourceW,
     [HANDLE, LPCWSTR, LPCWSTR, WORD, LPVOID, DWORD],
     BOOL,
-    check_zero)
+    check_false)
 
 _BaseGetWindowsDirectory = function_factory(
     kernel32.GetWindowsDirectoryW,
@@ -170,19 +172,18 @@ def _GetSystemDirectory():
 def _UpdateResource(hUpdate, lpType, lpName, wLanguage, lpData, cbData):
     lp_type = LPCWSTR(lpType)
     lp_name = LPCWSTR(lpName)
-    return _BaseUpdateResource(hUpdate, lp_type, lp_name, wLanguage, lpData, cbData)
+    _BaseUpdateResource(hUpdate, lp_type, lp_name, wLanguage, lpData, cbData)
 
 
 def _EnumResourceNames(hModule, lpszType, lpEnumFunc, lParam):
     resource_type = LPCWSTR(lpszType)
-    return _BaseEnumResourceNames(
-        hModule, resource_type, lpEnumFunc, lParam)
+    _BaseEnumResourceNames(hModule, resource_type, lpEnumFunc, lParam)
 
 
 def _EnumResourceLanguages(hModule, lpType, lpName, lpEnumFunc, lParam):
     resource_type = LPCWSTR(lpType)
     resource_name = LPCWSTR(lpName)
-    return _BaseEnumResourceLanguages(
+    _BaseEnumResourceLanguages(
         hModule, resource_type, resource_name, lpEnumFunc, lParam)
 
 

win32ctypes/core/ctypes/_util.py

@@ -43,6 +43,7 @@ def check_null(result, function, arguments, *args):
         return result
     return check_null
 
+
 check_null = check_null_factory()
 
 
@@ -53,4 +54,17 @@ def check_zero(result, function, arguments, *args):
         return result
     return check_zero
 
+
 check_zero = check_zero_factory()
+
+
+def check_false_factory(function_name=None):
+    def check_false(result, function, arguments, *args):
+        if not bool(result):
+            raise make_error(function, function_name)
+        else:
+            return True
+    return check_false
+
+
+check_false = check_false_factory()