more TU

trolldbois · trolldbois · commit fe0db2fe7abf · 2013-12-30T15:50:29.000-07:00
diff --git a/haystack/utils.py b/haystack/utils.py
@@ -115,7 +115,9 @@ def getaddress(obj):
 
 def container_of(memberaddr, typ, membername):
     """
+    From a pointer to a member, returns the parent struct.
     Returns the instance of typ(), in which the member "membername' is really.
+    Useful in some Kernel linked list which used members as prec,next pointers.
 
     :param memberadd: the address of membername.
     :param typ: the type of the containing structure.
@@ -134,8 +136,6 @@ def offsetof(typ, membername):
     :param typ: the structure type.
     :param membername: the membername in that structure.
     """
-    #T=typ()
-    #return ctypes.addressof(  getattr(T,membername) ) - ctypes.addressof(T)
     return getattr(typ, membername).offset
 
 
@@ -194,7 +194,8 @@ def array2bytes(array):
   
   This is a bad example of introspection.
   """
-  if not isBasicTypeArray(array):
+  import ctypes
+  if not ctypes.is_array_of_basic_instance(array):
     return b'NOT-AN-BasicType-ARRAY'
   # BEURK
   #log.info(type(array).__name__.split('_'))
@@ -267,7 +268,7 @@ def isCTypes(obj):
 
 @deprecated
 def isBasicTypeArray(obj):
-    return ctypes.is_array_to_basic_instance(obj)
+    return ctypes.is_array_of_basic_instance(obj)
 
 @deprecated
 def isBasicType(objtype):
diff --git a/test/haystack/test_utils.py b/test/haystack/test_utils.py
@@ -13,14 +13,14 @@
 # init ctypes with a controlled type size
 from haystack import model
 from haystack import utils
+from haystack import types
 
 import unittest
 
 class TestHelpers(unittest.TestCase):
     """Tests helpers functions."""
 
     def test_formatAddress(self):
-        from haystack import types
         types.reload_ctypes(8,8,16)
         x = utils.formatAddress(0x12345678)
         self.assertEquals('0x0000000012345678', x)
@@ -30,7 +30,6 @@ def test_formatAddress(self):
         self.assertEquals('0x12345678', x)
 
     def test_unpackWord(self):
-        from haystack import types
         # 64b
         types.reload_ctypes(8,8,16)
         one = b'\x01'+7*b'\x00'
@@ -64,7 +63,6 @@ def test_is_address_local(self):
 
     def test_getaddress(self):
         """tests getaddress on host ctypes POINTER and haystack POINTER"""
-        from haystack import types
         ctypes = types.reload_ctypes(8,8,16)
         class X(ctypes.Structure):
             _pack_ = True
@@ -109,12 +107,65 @@ class Y(ctypes.Structure):
 
         pass
 
-    def test_container_of(self):
-        #utils.container_of(memberaddr, typ, membername):
-        pass
     def test_offsetof(self):
-        #utils.offsetof(typ, membername):
+        """returns the offset of a member fields in a record"""
+        ctypes = types.reload_ctypes(4,4,8)
+        class Y(ctypes.Structure):
+            _pack_ = True
+            _fields_ = [('a',ctypes.c_long),
+                ('p',ctypes.POINTER(ctypes.c_int)),
+                ('b', ctypes.c_ubyte)]
+        o = utils.offsetof(Y, 'b')
+        self.assertEquals( o, 8)
+
+        ctypes = types.reload_ctypes(8,8,16)
+        class X(ctypes.Structure):
+            _pack_ = True
+            _fields_ = [('a',ctypes.c_long),
+                ('p',ctypes.POINTER(ctypes.c_int)),
+                ('b', ctypes.c_ubyte)]
+        o = utils.offsetof(X, 'b')
+        self.assertEquals( o, 16)
+
+        class X2(ctypes.Union):
+            _pack_ = True
+            _fields_ = [('a',ctypes.c_long),
+                ('p',ctypes.POINTER(ctypes.c_int)),
+                ('b', ctypes.c_ubyte)]
+        o = utils.offsetof(X2, 'b')
+        self.assertEquals( o, 0)
+        pass
+
+    def test_container_of(self):
+        """From a pointer to a member, returns the parent struct"""
+        # depends on offsetof
+        ctypes = types.reload_ctypes(8,8,16)
+        class X(ctypes.Structure):
+            _pack_ = True
+            _fields_ = [('a',ctypes.c_long),
+                ('p',ctypes.POINTER(ctypes.c_int)),
+                ('b', ctypes.c_ubyte)]
+        x = X()
+        x.a = 1
+        x.b = 2
+        addr_b = ctypes.addressof(x) + 16 # a + p
+        o = utils.container_of(addr_b, X, 'b')
+        self.assertEquals( ctypes.addressof(o), ctypes.addressof(x))
+
+        ctypes = types.reload_ctypes(4,4,8)
+        class Y(ctypes.Structure):
+            _pack_ = True
+            _fields_ = [('a',ctypes.c_long),
+                ('p',ctypes.POINTER(ctypes.c_int)),
+                ('b', ctypes.c_ubyte)]
+        y = Y()
+        y.a = 1
+        y.b = 2
+        addr_b = ctypes.addressof(y) + 8 # a + p
+        o = utils.container_of(addr_b, Y, 'b')
+        self.assertEquals( ctypes.addressof(o), ctypes.addressof(y))
         pass
+
     def test_array2bytes_(self):
         #utils.array2bytes_(array, typ):
         pass
