Fix event listener crash

The MI operation cancel/close calls are asynchronuous for async
subscriptions. The issue is that we're not waiting for those
operations to complete when tearing down event watchers.

For this reason, we may get event callbacks after deallocating
those objects, which will lead to invalid memory access and
crashes.

This can be avoided by waiting for the MI operations to be canceled
before going further with the teardown. After MI operations are
canceled, a cancel notification is emitted and the "more_results"
is set to False. We'll just wait for that.

Author: petrutlucian94

PyMI/src/wmi/__init__.py

@@ -434,6 +434,7 @@ def __init__(self, conn, wql):
         self._event = native_threading.Event()
         self._operation = conn.subscribe(
             wql, self._indication_result, self.close)
+        self._operation_finished = native_threading.Event()
 
     def _process_events(self):
         if self._error:
@@ -463,6 +464,9 @@ def __call__(self, timeout_ms=-1):
 
     def _indication_result(self, instance, bookmark, machine_id, more_results,
                            result_code, error_string, error_details):
+        if not more_results:
+            self._operation_finished.set()
+
         if self._conn_ref:
             conn = self._conn_ref()
             if conn:
@@ -490,10 +494,22 @@ def _indication_result(self, instance, bookmark, machine_id, more_results,
                             use_conn_weak_ref=True))
                 self._event.set()
 
+    @avoid_blocking_call
+    def _wait_for_operation_cancel(self):
+        self._operation_finished.wait()
+
     def close(self):
         if self._operation:
             self._operation.cancel()
+            # Those operations are asynchronous. We'll need to wait for the
+            # subscription to be canceled before deallocating objects,
+            # otherwise MI can crash when receiving further events. We rely on
+            # the fact that an event will be emitted once the subscription is
+            # canceled.
+            self._wait_for_operation_cancel()
+
             self._operation.close()
+
         self._event.set()
         self._operation = None
         self._timeout_ms = None