proj: Implement InterruptedCheckTester

2025-02-17 20:15:01 +01:00
parent cc2b270d8f
commit 3db8439a9b
4 changed files with 229 additions and 65 deletions
--- a/proj/server/src/intercept.py
+++ b/proj/server/src/intercept.py
@@ -19,13 +19,13 @@ class ThreadedUnixStreamServer(ThreadingMixIn, UnixStreamServer):

 class Handler(StreamRequestHandler):
    pid: int
-    stack: list[tuple[str, tuple]]
+    stack: list[tuple[int, str, tuple]]
+    ret_addr: int

-    def before(self) -> None:
-        pass
-
-    def after(self) -> None:
-        pass
+    def before(self) -> None: pass
+    def after(self) -> None: pass
+    def before_fallback(self, func_name: str, *args) -> str: pass
+    def after_fallback(self, func_name: str, *args, **kwargs) -> None: pass

    def handle(self):
        first = self.rfile.readline()
@@ -93,7 +93,7 @@ class Handler(StreamRequestHandler):
        idx = len(m.group(0))
        if a.startswith('0x'):
            val = int(a[2:], 16)
-        elif a.startswith('0'):
+        elif a.startswith('0') and len(a) > 1:
            val = int(a[1:], 8)
        else:
            val = int(a, 10)
@@ -157,68 +157,131 @@ class Handler(StreamRequestHandler):
            call = data.decode('utf-8')
            print(f'[{self.pid}] {call}')
            func_name = call[:call.find('(')]
-            args, _ = Handler.parse_args(call[call.find('(') + 1:-1])
-            self.stack.append((func_name, args))
+            self.ret_addr = int(call[call.rfind(':') + 1:], 0)
+            args, _ = Handler.parse_args(call[call.find('(') + 1:call.rfind(':') - 1])
+            self.stack.append((self.ret_addr, func_name, args))
            try:
                func = getattr(self, f'before_{func_name}')
-                if callable(func):
-                    command = func(*args) or 'ok'
-                else:
-                    command = 'ok'
+                if not callable(func):
+                    func = None
            except AttributeError:
-                command = 'ok'
+                func = None
+            try:
+                if func is None:
+                    raise NotImplementedError()
+                command = func(*args) or self.before_fallback(func_name, *args) or 'ok'
+            except NotImplementedError:
+                command = self.before_fallback(func_name, *args) or 'ok'
            print(f'[{self.pid}]  -> {command}')
            self.wfile.write(command.encode('utf-8') + b'\n')
        else:
            ret = data.decode('utf-8')
-            ret_value, _ = Handler.parse_arg(ret[7:])
-            func_name, args = self.stack.pop()
+            ret_value, _ = Handler.parse_arg(ret[7:].split(';')[0])
+            self.ret_addr, func_name, args = self.stack.pop()
            try:
                func = getattr(self, f'after_{func_name}')
-                if callable(func):
-                    if ret_value is None:
-                        func(*args)
-                    else:
-                        func(*args, ret_value)
+                if not callable(func):
+                    func = None
            except AttributeError:
-                pass
+                func = None
+            try:
+                if func is None:
+                    raise NotImplementedError()
+                if ret_value is None:
+                    func(*args)
+                else:
+                    func(*args, ret_value)
+            except NotImplementedError:
+                if ret_value is None:
+                    self.after_fallback(func_name, *args)
+                else:
+                    self.after_fallback(func_name, *args, ret_value)
            print(f'[{self.pid}]  -> {ret}')

-    def before_malloc(self, size: int) -> str: pass
+    def before_malloc(self, size: int) -> str:
+        raise NotImplementedError()
    def after_malloc(self, size: int,
-                     ret_value: int, errno: str = None) -> None: pass
-    def before_calloc(self, nmemb: int, size: int) -> str: pass
+                     ret_value: int, errno: str = None) -> None:
+        raise NotImplementedError()
+    def before_calloc(self, nmemb: int, size: int) -> str:
+        raise NotImplementedError()
    def after_calloc(self, nmemb: int, size: int,
-                     ret_value: int, errno: str = None) -> None: pass
-    def before_realloc(self, ptr: int, size: int) -> str: pass
+                     ret_value: int, errno: str = None) -> None:
+        raise NotImplementedError()
+    def before_realloc(self, ptr: int, size: int) -> str:
+        raise NotImplementedError()
    def after_realloc(self, ptr: int, size: int,
-                      ret_value: int, errno: str = None) -> None: pass
-    def before_reallocarray(self, ptr: int, nmemb: int, size: int) -> str: pass
+                      ret_value: int, errno: str = None) -> None:
+        raise NotImplementedError()
+    def before_reallocarray(self, ptr: int, nmemb: int, size: int) -> str:
+        raise NotImplementedError()
    def after_reallocarray(self, ptr: int, nmemb: int, size: int,
-                           ret_value: int, errno: str = None) -> None: pass
-    def before_free(self, ptr: int) -> str: pass
-    def after_free(self, ptr: int) -> None: pass
-    def before_getopt(self, argc: int, argv: Pointer[list[Pointer[bytes]]], optstring: Pointer[bytes]) -> str: pass
+                           ret_value: int, errno: str = None) -> None:
+        raise NotImplementedError()
+    def before_free(self, ptr: int) -> str:
+        raise NotImplementedError()
+    def after_free(self, ptr: int) -> None:
+        raise NotImplementedError()
+    def before_getopt(self, argc: int, argv: Pointer[list[Pointer[bytes]]], optstring: Pointer[bytes]) -> str:
+        raise NotImplementedError()
    def after_getopt(self, argc: int, argv: Pointer[list[Pointer[bytes]]], optstring: Pointer[bytes],
-                     ret_value: int) -> None: pass
-    def before_close(self, fildes: int) -> str: pass
+                     ret_value: int) -> None:
+        raise NotImplementedError()
+    def before_close(self, fildes: int) -> str:
+        raise NotImplementedError()
    def after_close(self, fildes: int,
-                    ret_value: int, errno: str = None) -> None: pass
-    def before_sem_init(self, sem: int, pshared: int, value: int) -> str: pass
+                    ret_value: int, errno: str = None) -> None:
+        raise NotImplementedError()
+    def before_sem_init(self, sem: int, pshared: int, value: int) -> str:
+        raise NotImplementedError()
    def after_sem_init(self, sem: int, pshared: int, value: int,
-                       ret_value: int, errno: str = None) -> None: pass
-    def before_sem_open(self, name: str, oflag: Flags, mode: Optional[int], value: Optional[int]) -> str: pass
+                       ret_value: int, errno: str = None) -> None:
+        raise NotImplementedError()
+    def before_sem_open(self, name: str, oflag: Flags, mode: Optional[int], value: Optional[int]) -> str:
+        raise NotImplementedError()
    def after_sem_open(self, name: str, oflag: Flags, mode: Optional[int], value: Optional[int],
-                       ret_value: int, errno: str = None) -> None: pass
-    def before_sem_post(self, sem: int) -> str: pass
+                       ret_value: int, errno: str = None) -> None:
+        raise NotImplementedError()
+    def before_sem_post(self, sem: int) -> str:
+        raise NotImplementedError()
    def after_sem_post(self, sem: int,
-                       ret_value: int, errno: str = None) -> None: pass
-    def before_sem_wait(self, sem: int) -> str: pass
+                       ret_value: int, errno: str = None) -> None:
+        raise NotImplementedError()
+    def before_sem_wait(self, sem: int) -> str:
+        raise NotImplementedError()
    def after_sem_wait(self, sem: int,
-                       ret_value: int, errno: str = None) -> None: pass
-    def before_sem_timedwait(self, sem: int, abs_timeout: Pointer[StructTimeSpec]): pass
+                       ret_value: int, errno: str = None) -> None:
+        raise NotImplementedError()
+    def before_sem_trywait(self, sem: int) -> str:
+        raise NotImplementedError()
+    def after_sem_trywait(self, sem: int,
+                          ret_value: int, errno: str = None) -> None:
+        raise NotImplementedError()
+    def before_sem_timedwait(self, sem: int, abs_timeout: Pointer[StructTimeSpec]) -> str:
+        raise NotImplementedError()
    def after_sem_timedwait(self, sem: int, abs_timeout: Pointer[StructTimeSpec],
-                            ret_value: int, errno: str = None): pass
+                            ret_value: int, errno: str = None) -> None:
+        raise NotImplementedError()
+    def before_sem_getvalue(self, sem: int, value_ptr: int) -> str:
+        raise NotImplementedError()
+    def after_sem_getvalue(self, sem:int, value_ptr: int,
+                           ret_value: int, errno: str = None, value: int = None) -> None:
+        raise NotImplementedError()
+    def before_sem_close(self, sem: int) -> str:
+        raise NotImplementedError()
+    def after_sem_close(self, sem: int,
+                        ret_value: int, errno: str = None) -> None:
+        raise NotImplementedError()
+    def before_sem_unlink(self, name: Pointer[bytes]) -> str:
+        raise NotImplementedError()
+    def after_sem_unlink(self, name: Pointer[bytes],
+                         ret_value: int, errno: str = None) -> None:
+        raise NotImplementedError()
+    def before_sem_destroy(self, sem: int) -> str:
+        raise NotImplementedError()
+    def after_sem_destroy(self, sem: int,
+                          ret_value: int, errno: str = None) -> None:
+        raise NotImplementedError()


 class MemoryAllocationTester(Handler):
@@ -284,6 +347,82 @@ class MemoryAllocationTester(Handler):
            del self.allocated[ptr]


+class ReturnValueCheckTester(Handler):
+    pass
+
+
+class InterruptedCheckTester(Handler):
+    cycles: int = 50
+    counter: int = 0
+    last_func_name: Optional[str] = None
+    last_ret_addr: Optional[int] = None
+    tested_functions: dict[tuple[str, int], str]
+
+    @property
+    def while_testing(self) -> bool:
+        return self.counter % self.cycles != 0
+
+    def before(self) -> None:
+        self.tested_functions = {}
+
+    def after(self) -> None:
+        if self.while_testing:
+            self.error()
+        for (name, ret_addr), status in self.tested_functions.items():
+            print(f'{name} (0x{ret_addr:x}) -> {status}')
+
+    def error(self):
+        print(f'Error: Return value and errno EINTR not handled correctly in {self.last_func_name} (return address 0x{self.last_ret_addr:x})')
+        self.tested_functions[(self.last_func_name, self.last_ret_addr)] = 'failed'
+        self.counter = 0
+        self.last_func_name = None
+        self.last_ret_addr = None
+
+    def after_fallback(self, func_name: str, *args, **kwargs) -> None:
+        if self.while_testing and self.last_func_name != func_name:
+            self.error()
+
+    def before_sem_wait(self, sem: int) -> str:
+        if self.last_ret_addr and self.last_ret_addr != self.ret_addr:
+            self.error()
+        self.counter += 1
+        if self.while_testing:
+            self.last_ret_addr = self.ret_addr
+            self.last_func_name = 'sem_wait'
+            self.tested_functions[(self.last_func_name, self.last_ret_addr)] = 'running'
+            return 'fail EINTR'
+        else:
+            self.tested_functions[(self.last_func_name, self.last_ret_addr)] = 'passed'
+            self.last_ret_addr = None
+            self.last_func_name = None
+            return 'return 0'
+
+    def before_sem_trywait(self, sem: int) -> str:
+        self.counter += 1
+        if self.while_testing:
+            self.last_ret_addr = self.ret_addr
+            self.last_func_name = 'sem_trywait'
+            return 'fail EINTR'
+        else:
+            self.last_ret_addr = None
+            self.last_func_name = None
+            return 'return 0'
+
+    def before_sem_timedwait(self, sem: int, abs_timeout: Pointer[StructTimeSpec]) -> str:
+        self.counter += 1
+        if self.while_testing:
+            self.last_ret_addr = self.ret_addr
+            self.last_func_name = 'sem_timedwait'
+            return 'fail EINTR'
+        else:
+            self.last_ret_addr = None
+            self.last_func_name = None
+            return 'return 0'
+
+    def before_sem_post(self, sem: int) -> str:
+        return 'return 0'
+
+
 def intercept(socket: str, handler: type[Handler]) -> None:
    try:
        with ThreadedUnixStreamServer(socket, handler) as server:
--- a/proj/server/src/server.py
+++ b/proj/server/src/server.py
@@ -39,7 +39,7 @@ def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument('socket', metavar='FILE')
    args = parser.parse_args()
-    intercept.intercept(args.socket, intercept.MemoryAllocationTester)
+    intercept.intercept(args.socket, intercept.InterruptedCheckTester)


 if __name__ == '__main__':