Implement NtQueryEvent

Andrew Cook ariscop at gmail.com
Mon Jun 3 20:11:49 CDT 2013


---
 dlls/ntdll/sync.c              | 32 ++++++++++++++++++++++++++++++--
 include/wine/server_protocol.h | 16 +++++++++++++++-
 server/event.c                 | 13 +++++++++++++
 server/protocol.def            |  6 ++++++
 server/request.h               |  7 +++++++
 server/trace.c                 | 14 ++++++++++++++
 6 files changed, 85 insertions(+), 3 deletions(-)

diff --git a/dlls/ntdll/sync.c b/dlls/ntdll/sync.c
index 58dde65..d12ff3e 100644
--- a/dlls/ntdll/sync.c
+++ b/dlls/ntdll/sync.c
@@ -397,8 +397,36 @@ NTSTATUS WINAPI NtQueryEvent (
 	IN  ULONG EventInformationLength,
 	OUT PULONG  ReturnLength)
 {
-	FIXME("(%p)\n", EventHandle);
-	return STATUS_NOT_IMPLEMENTED;
+    NTSTATUS ret;
+    PEVENT_BASIC_INFORMATION out;
+
+    if(EventInformationClass != EventBasicInformation) {
+        FIXME("(%p, %d, %d) Unknown EventInformationClass\n",
+                EventHandle,
+                EventInformationClass,
+                EventInformationLength);
+        return STATUS_INVALID_INFO_CLASS;
+    }
+
+    if(EventInformationLength != sizeof(EVENT_BASIC_INFORMATION))
+        return STATUS_INFO_LENGTH_MISMATCH;
+
+    out = (PEVENT_BASIC_INFORMATION)EventInformation;
+
+    SERVER_START_REQ( event_query )
+    {
+        req->handle = EventHandle;
+        ret = wine_server_call( req );
+        if(ret == STATUS_SUCCESS) {
+            out->EventType  = reply->type == 0;
+            out->EventState = reply->state;
+            if(ReturnLength)
+                *ReturnLength = sizeof(EVENT_BASIC_INFORMATION);
+        }
+    }
+    SERVER_END_REQ;
+
+    return ret;
 }
  /*
diff --git a/include/wine/server_protocol.h b/include/wine/server_protocol.h
index 6f3a5d6..3dc0b1c 100644
--- a/include/wine/server_protocol.h
+++ b/include/wine/server_protocol.h
@@ -1103,6 +1103,17 @@ struct event_op_reply
 };
 enum event_op { PULSE_EVENT, SET_EVENT, RESET_EVENT };
 +struct event_query_request
+{
+    struct request_header __header;
+    obj_handle_t handle;
+};
+struct event_query_reply
+{
+    struct reply_header __header;
+    int          type;
+    int          state;
+};
   struct open_event_request
@@ -4981,6 +4992,7 @@ enum request
     REQ_select,
     REQ_create_event,
     REQ_event_op,
+    REQ_event_query,
     REQ_open_event,
     REQ_create_mutex,
     REQ_release_mutex,
@@ -5237,6 +5249,7 @@ union generic_request
     struct select_request select_request;
     struct create_event_request create_event_request;
     struct event_op_request event_op_request;
+    struct event_query_request event_query_request;
     struct open_event_request open_event_request;
     struct create_mutex_request create_mutex_request;
     struct release_mutex_request release_mutex_request;
@@ -5491,6 +5504,7 @@ union generic_reply
     struct select_reply select_reply;
     struct create_event_reply create_event_reply;
     struct event_op_reply event_op_reply;
+    struct event_query_reply event_query_reply;
     struct open_event_reply open_event_reply;
     struct create_mutex_reply create_mutex_reply;
     struct release_mutex_reply release_mutex_reply;
@@ -5715,6 +5729,6 @@ union generic_reply
     struct set_suspend_context_reply set_suspend_context_reply;
 };
 -#define SERVER_PROTOCOL_VERSION 440
+#define SERVER_PROTOCOL_VERSION 441
  #endif /* __WINE_WINE_SERVER_PROTOCOL_H */
diff --git a/server/event.c b/server/event.c
index 7a7331d..d792ccd 100644
--- a/server/event.c
+++ b/server/event.c
@@ -249,3 +249,16 @@ DECL_HANDLER(event_op)
     }
     release_object( event );
 }
+
+/* return details about the event */
+DECL_HANDLER(event_query)
+{
+    struct event *event;
+
+    if (!(event = get_event_obj( current->process, req->handle,
EVENT_QUERY_STATE ))) return;
+
+    reply->type  = event->manual_reset;
+    reply->state = event->signaled;
+
+    release_object( event );
+}
diff --git a/server/protocol.def b/server/protocol.def
index 234c41e..55eea2e 100644
--- a/server/protocol.def
+++ b/server/protocol.def
@@ -953,6 +953,12 @@ struct rawinput_device
 @END
 enum event_op { PULSE_EVENT, SET_EVENT, RESET_EVENT };
 + at REQ(event_query)
+    obj_handle_t handle;
+ at REPLY
+    int          type;
+    int          state;
+ at END
  /* Open an event */
 @REQ(open_event)
diff --git a/server/request.h b/server/request.h
index 816d763..f23c2d5 100644
--- a/server/request.h
+++ b/server/request.h
@@ -133,6 +133,7 @@ DECL_HANDLER(open_thread);
 DECL_HANDLER(select);
 DECL_HANDLER(create_event);
 DECL_HANDLER(event_op);
+DECL_HANDLER(event_query);
 DECL_HANDLER(open_event);
 DECL_HANDLER(create_mutex);
 DECL_HANDLER(release_mutex);
@@ -388,6 +389,7 @@ static const req_handler req_handlers[REQ_NB_REQUESTS] =
     (req_handler)req_select,
     (req_handler)req_create_event,
     (req_handler)req_event_op,
+    (req_handler)req_event_query,
     (req_handler)req_open_event,
     (req_handler)req_create_mutex,
     (req_handler)req_release_mutex,
@@ -828,6 +830,11 @@ C_ASSERT( sizeof(struct create_event_reply) == 16 );
 C_ASSERT( FIELD_OFFSET(struct event_op_request, handle) == 12 );
 C_ASSERT( FIELD_OFFSET(struct event_op_request, op) == 16 );
 C_ASSERT( sizeof(struct event_op_request) == 24 );
+C_ASSERT( FIELD_OFFSET(struct event_query_request, handle) == 12 );
+C_ASSERT( sizeof(struct event_query_request) == 16 );
+C_ASSERT( FIELD_OFFSET(struct event_query_reply, type) == 8 );
+C_ASSERT( FIELD_OFFSET(struct event_query_reply, state) == 12 );
+C_ASSERT( sizeof(struct event_query_reply) == 16 );
 C_ASSERT( FIELD_OFFSET(struct open_event_request, access) == 12 );
 C_ASSERT( FIELD_OFFSET(struct open_event_request, attributes) == 16 );
 C_ASSERT( FIELD_OFFSET(struct open_event_request, rootdir) == 20 );
diff --git a/server/trace.c b/server/trace.c
index a183fde..7a00ab3 100644
--- a/server/trace.c
+++ b/server/trace.c
@@ -1391,6 +1391,17 @@ static void dump_event_op_request( const struct
event_op_request *req )
     fprintf( stderr, ", op=%d", req->op );
 }
 +static void dump_event_query_request( const struct event_query_request
*req )
+{
+    fprintf( stderr, " handle=%04x", req->handle );
+}
+
+static void dump_event_query_reply( const struct event_query_reply *req )
+{
+    fprintf( stderr, " type=%d", req->type );
+    fprintf( stderr, ", state=%d", req->state );
+}
+
 static void dump_open_event_request( const struct open_event_request *req )
 {
     fprintf( stderr, " access=%08x", req->access );
@@ -4007,6 +4018,7 @@ static const dump_func
req_dumpers[REQ_NB_REQUESTS] = {
     (dump_func)dump_select_request,
     (dump_func)dump_create_event_request,
     (dump_func)dump_event_op_request,
+    (dump_func)dump_event_query_request,
     (dump_func)dump_open_event_request,
     (dump_func)dump_create_mutex_request,
     (dump_func)dump_release_mutex_request,
@@ -4259,6 +4271,7 @@ static const dump_func
reply_dumpers[REQ_NB_REQUESTS] = {
     (dump_func)dump_select_reply,
     (dump_func)dump_create_event_reply,
     NULL,
+    (dump_func)dump_event_query_reply,
     (dump_func)dump_open_event_reply,
     (dump_func)dump_create_mutex_reply,
     (dump_func)dump_release_mutex_reply,
@@ -4511,6 +4524,7 @@ static const char * const
req_names[REQ_NB_REQUESTS] = {
     "select",
     "create_event",
     "event_op",
+    "event_query",
     "open_event",
     "create_mutex",
     "release_mutex",
-- 
1.8.3




More information about the wine-patches mailing list