diff --git a/server/named_pipe.c b/server/named_pipe.c
index 2917d7b..bda6bd9 100644
--- a/server/named_pipe.c
+++ b/server/named_pipe.c
@@ -679,8 +679,7 @@
     server = create_pipe_server( pipe, req->options );
     if (server)
     {
-        reply->handle = alloc_handle( current->process, server,
-                                      req->access, req->attributes & OBJ_INHERIT );
+        reply->handle = alloc_handle( current->process, server, req->access, req->attributes );
         server->pipe->instances++;
         release_object( server );
     }
@@ -745,8 +744,7 @@
                 server->state = ps_connected_server;
                 server->client = client;
                 client->server = server;
-                reply->handle = alloc_handle( current->process, client,
-                                              req->access, req->attributes & OBJ_INHERIT );
+                reply->handle = alloc_handle( current->process, client, req->access, req->attributes );
             }
         }
         else
