diff --git a/server/console.c b/server/console.c
index bbadc1b..9fdbde84 100644
--- a/server/console.c
+++ b/server/console.c
@@ -227,7 +227,7 @@
     console_input->history_index = 0;
     console_input->history_mode  = 0;
     console_input->edition_mode  = 0;
-    console_input->event         = create_event( NULL, 0, 1, 0 );
+    console_input->event         = create_event( NULL, 0, 0, 1, 0 );
 
     if (!console_input->history || !console_input->evt)
     {
diff --git a/server/event.c b/server/event.c
index 43b64af..7e06b1b 100644
--- a/server/event.c
+++ b/server/event.c
@@ -59,12 +59,12 @@
 };
 
 
-struct event *create_event( const WCHAR *name, size_t len,
+struct event *create_event( const WCHAR *name, size_t len, unsigned int attr,
                             int manual_reset, int initial_state )
 {
     struct event *event;
 
-    if ((event = create_named_object( sync_namespace, &event_ops, name, len )))
+    if ((event = create_named_object( sync_namespace, &event_ops, name, len, attr )))
     {
         if (get_error() != STATUS_OBJECT_NAME_COLLISION)
         {
@@ -147,7 +147,7 @@
     struct event *event;
 
     reply->handle = 0;
-    if ((event = create_event( get_req_data(), get_req_data_size(),
+    if ((event = create_event( get_req_data(), get_req_data_size(), req->attributes,
                                req->manual_reset, req->initial_state )))
     {
         reply->handle = alloc_handle( current->process, event, req->access,
diff --git a/server/handle.c b/server/handle.c
index b865fd3..5eda36b 100644
--- a/server/handle.c
+++ b/server/handle.c
@@ -525,7 +525,7 @@
                           const struct object_ops *ops, unsigned int access, unsigned int attr )
 {
     obj_handle_t handle = 0;
-    struct object *obj = find_object( namespace, name, len );
+    struct object *obj = find_object( namespace, name, len, attr );
     if (obj)
     {
         if (ops && obj->ops != ops)
diff --git a/server/mailslot.c b/server/mailslot.c
index d461a52..26432c1 100644
--- a/server/mailslot.c
+++ b/server/mailslot.c
@@ -213,8 +213,8 @@
     fd_queue_async_timeout( fd, apc, user, iosb, type, count, timeout );
 }
 
-static struct mailslot *create_mailslot( const WCHAR *name, size_t len, int max_msgsize,
-                                         int read_timeout )
+static struct mailslot *create_mailslot( const WCHAR *name, size_t len, unsigned int attr,
+                                         int max_msgsize, int read_timeout )
 {
     struct mailslot *mailslot;
     int fds[2];
@@ -226,7 +226,7 @@
         return NULL;
     }
 
-    mailslot = create_named_object( sync_namespace, &mailslot_ops, name, len );
+    mailslot = create_named_object( sync_namespace, &mailslot_ops, name, len, attr );
     if (!mailslot)
         return NULL;
 
@@ -259,11 +259,11 @@
     return NULL;
 }
 
-static struct mailslot *open_mailslot( const WCHAR *name, size_t len )
+static struct mailslot *open_mailslot( const WCHAR *name, size_t len, unsigned int attr )
 {
     struct object *obj;
 
-    obj = find_object( sync_namespace, name, len );
+    obj = find_object( sync_namespace, name, len, attr );
     if (obj)
     {
         if (obj->ops == &mailslot_ops)
@@ -352,7 +352,7 @@
     struct mailslot *mailslot;
 
     reply->handle = 0;
-    mailslot = create_mailslot( get_req_data(), get_req_data_size(),
+    mailslot = create_mailslot( get_req_data(), get_req_data_size(), req->attributes,
                                 req->max_msgsize, req->read_timeout );
     if (mailslot)
     {
@@ -376,7 +376,7 @@
         return;
     }
 
-    mailslot = open_mailslot( get_req_data(), get_req_data_size() );
+    mailslot = open_mailslot( get_req_data(), get_req_data_size(), req->attributes );
     if (mailslot)
     {
         struct mail_writer *writer;
diff --git a/server/mapping.c b/server/mapping.c
index 7edba4c..984fa7c 100644
--- a/server/mapping.c
+++ b/server/mapping.c
@@ -270,15 +270,15 @@
     return 1;
 }
 
-static struct object *create_mapping( file_pos_t size, int protect, obj_handle_t handle,
-                                      const WCHAR *name, size_t len )
+static struct object *create_mapping( const WCHAR *name, size_t len, unsigned int attr,
+                                      file_pos_t size, int protect, obj_handle_t handle )
 {
     struct mapping *mapping;
     int access = 0;
 
     if (!page_mask) init_page_size();
 
-    if (!(mapping = create_named_object( sync_namespace, &mapping_ops, name, len )))
+    if (!(mapping = create_named_object( sync_namespace, &mapping_ops, name, len, attr )))
         return NULL;
     if (get_error() == STATUS_OBJECT_NAME_COLLISION)
         return &mapping->obj;  /* Nothing else to do */
@@ -377,8 +377,8 @@
     file_pos_t size = ((file_pos_t)req->size_high << 32) | req->size_low;
 
     reply->handle = 0;
-    if ((obj = create_mapping( size, req->protect, req->file_handle,
-                               get_req_data(), get_req_data_size() )))
+    if ((obj = create_mapping( get_req_data(), get_req_data_size(), req->attributes,
+                               size, req->protect, req->file_handle )))
     {
         reply->handle = alloc_handle( current->process, obj, req->access,
                                       req->attributes & OBJ_INHERIT );
diff --git a/server/mutex.c b/server/mutex.c
index e773d44..3388cc5 100644
--- a/server/mutex.c
+++ b/server/mutex.c
@@ -62,11 +62,12 @@
 };
 
 
-static struct mutex *create_mutex( const WCHAR *name, size_t len, int owned )
+static struct mutex *create_mutex( const WCHAR *name, size_t len, unsigned int attr,
+                                   int owned )
 {
     struct mutex *mutex;
 
-    if ((mutex = create_named_object( sync_namespace, &mutex_ops, name, len )))
+    if ((mutex = create_named_object( sync_namespace, &mutex_ops, name, len, attr )))
     {
         if (get_error() != STATUS_OBJECT_NAME_COLLISION)
         {
@@ -172,7 +173,8 @@
     struct mutex *mutex;
 
     reply->handle = 0;
-    if ((mutex = create_mutex( get_req_data(), get_req_data_size(), req->owned )))
+    if ((mutex = create_mutex( get_req_data(), get_req_data_size(), req->attributes,
+                               req->owned )))
     {
         reply->handle = alloc_handle( current->process, mutex, req->access,
                                       req->attributes & OBJ_INHERIT );
diff --git a/server/named_pipe.c b/server/named_pipe.c
index 6f4e55d..d461052 100644
--- a/server/named_pipe.c
+++ b/server/named_pipe.c
@@ -397,7 +397,7 @@
 
         /* this kind of sux - 
            there's no unix way to be alerted when a pipe becomes empty */
-        server->event = create_event( NULL, 0, 0, 0 );
+        server->event = create_event( NULL, 0, 0, 0, 0 );
         if (!server->event)
             return 0;
         gettimeofday( &tv, NULL );
@@ -440,11 +440,11 @@
     return flags;
 }
 
-static struct named_pipe *create_named_pipe( const WCHAR *name, size_t len )
+static struct named_pipe *create_named_pipe( const WCHAR *name, size_t len, unsigned int attr )
 {
     struct named_pipe *pipe;
 
-    pipe = create_named_object( sync_namespace, &named_pipe_ops, name, len );
+    pipe = create_named_object( sync_namespace, &named_pipe_ops, name, len, attr );
     if (pipe)
     {
         if (get_error() != STATUS_OBJECT_NAME_COLLISION)
@@ -458,11 +458,11 @@
     return pipe;
 }
 
-static struct named_pipe *open_named_pipe( const WCHAR *name, size_t len )
+static struct named_pipe *open_named_pipe( const WCHAR *name, size_t len, unsigned int attr )
 {
     struct object *obj;
 
-    if ((obj = find_object( sync_namespace, name, len )))
+    if ((obj = find_object( sync_namespace, name, len, attr )))
     {
         if (obj->ops == &named_pipe_ops) return (struct named_pipe *)obj;
         release_object( obj );
@@ -548,7 +548,7 @@
     struct pipe_server *server;
 
     reply->handle = 0;
-    pipe = create_named_pipe( get_req_data(), get_req_data_size() );
+    pipe = create_named_pipe( get_req_data(), get_req_data_size(), req->attributes );
     if (!pipe)
         return;
 
@@ -598,7 +598,7 @@
     struct named_pipe *pipe;
     int fds[2];
 
-    pipe = open_named_pipe( get_req_data(), get_req_data_size() );
+    pipe = open_named_pipe( get_req_data(), get_req_data_size(), req->attributes );
     if (!pipe)
     {
         set_error( STATUS_NO_SUCH_FILE );
@@ -697,7 +697,7 @@
     struct named_pipe *pipe;
     struct pipe_server *server;
 
-    if (!(pipe = open_named_pipe( get_req_data(), get_req_data_size() )))
+    if (!(pipe = open_named_pipe( get_req_data(), get_req_data_size(), OBJ_CASE_INSENSITIVE )))
     {
         set_error( STATUS_PIPE_NOT_AVAILABLE );
         return;
diff --git a/server/object.c b/server/object.c
index a66875a..26b0f29 100644
--- a/server/object.c
+++ b/server/object.c
@@ -157,14 +157,14 @@
 }
 
 void *create_named_object( struct namespace *namespace, const struct object_ops *ops,
-                           const WCHAR *name, size_t len )
+                           const WCHAR *name, size_t len, unsigned int attributes )
 {
     struct object *obj;
     struct object_name *name_ptr;
 
     if (!name || !len) return alloc_object( ops );
 
-    if ((obj = find_object( namespace, name, len )))
+    if ((obj = find_object( namespace, name, len, attributes )))
     {
         if (obj->ops != ops)
         {
@@ -225,7 +225,8 @@
 }
 
 /* find an object by its name; the refcount is incremented */
-struct object *find_object( const struct namespace *namespace, const WCHAR *name, size_t len )
+struct object *find_object( const struct namespace *namespace, const WCHAR *name, size_t len,
+                            unsigned int attributes )
 {
     const struct list *list, *p;
 
diff --git a/server/object.h b/server/object.h
index 681c807..a360ebe 100644
--- a/server/object.h
+++ b/server/object.h
@@ -94,13 +94,14 @@
 extern const WCHAR *get_object_name( struct object *obj, size_t *len );
 extern void dump_object_name( struct object *obj );
 extern void *create_named_object( struct namespace *namespace, const struct object_ops *ops,
-                                  const WCHAR *name, size_t len );
+                                  const WCHAR *name, size_t len, unsigned int attributes );
 extern struct namespace *create_namespace( unsigned int hash_size, int case_sensitive );
 /* grab/release_object can take any pointer, but you better make sure */
 /* that the thing pointed to starts with a struct object... */
 extern struct object *grab_object( void *obj );
 extern void release_object( void *obj );
-extern struct object *find_object( const struct namespace *namespace, const WCHAR *name, size_t len );
+extern struct object *find_object( const struct namespace *namespace, const WCHAR *name, size_t len,
+                                   unsigned int attributes );
 extern int no_add_queue( struct object *obj, struct wait_queue_entry *entry );
 extern int no_satisfied( struct object *obj, struct thread *thread );
 extern int no_signal( struct object *obj, unsigned int access );
@@ -115,7 +116,7 @@
 
 struct event;
 
-extern struct event *create_event( const WCHAR *name, size_t len,
+extern struct event *create_event( const WCHAR *name, size_t len, unsigned int attr,
                                    int manual_reset, int initial_state );
 extern struct event *get_event_obj( struct process *process, obj_handle_t handle, unsigned int access );
 extern void pulse_event( struct event *event );
diff --git a/server/process.c b/server/process.c
index a56d5e2..1b5a5e3 100644
--- a/server/process.c
+++ b/server/process.c
@@ -993,7 +993,7 @@
     generate_startup_debug_events( process, req->entry );
     set_process_startup_state( process, STARTUP_DONE );
 
-    if (req->gui) process->idle_event = create_event( NULL, 0, 1, 0 );
+    if (req->gui) process->idle_event = create_event( NULL, 0, 0, 1, 0 );
     if (current->suspend + process->suspend > 0) stop_thread( current );
     if (process->debugger) set_process_debug_flag( process, 1 );
 }
diff --git a/server/semaphore.c b/server/semaphore.c
index 6f3a7ea..1ba035b 100644
--- a/server/semaphore.c
+++ b/server/semaphore.c
@@ -59,7 +59,7 @@
 };
 
 
-static struct semaphore *create_semaphore( const WCHAR *name, size_t len,
+static struct semaphore *create_semaphore( const WCHAR *name, size_t len, unsigned int attr,
                                            unsigned int initial, unsigned int max )
 {
     struct semaphore *sem;
@@ -69,7 +69,7 @@
         set_error( STATUS_INVALID_PARAMETER );
         return NULL;
     }
-    if ((sem = create_named_object( sync_namespace, &semaphore_ops, name, len )))
+    if ((sem = create_named_object( sync_namespace, &semaphore_ops, name, len, attr )))
     {
         if (get_error() != STATUS_OBJECT_NAME_COLLISION)
         {
@@ -147,7 +147,7 @@
     struct semaphore *sem;
 
     reply->handle = 0;
-    if ((sem = create_semaphore( get_req_data(), get_req_data_size(),
+    if ((sem = create_semaphore( get_req_data(), get_req_data_size(), req->attributes,
                                  req->initial, req->max )))
     {
         reply->handle = alloc_handle( current->process, sem, req->access,
diff --git a/server/timer.c b/server/timer.c
index 1a7d0d8..c93a066 100644
--- a/server/timer.c
+++ b/server/timer.c
@@ -68,11 +68,12 @@
 
 
 /* create a timer object */
-static struct timer *create_timer( const WCHAR *name, size_t len, int manual )
+static struct timer *create_timer( const WCHAR *name, size_t len, unsigned int attr,
+                                   int manual )
 {
     struct timer *timer;
 
-    if ((timer = create_named_object( sync_namespace, &timer_ops, name, len )))
+    if ((timer = create_named_object( sync_namespace, &timer_ops, name, len, attr )))
     {
         if (get_error() != STATUS_OBJECT_NAME_COLLISION)
         {
@@ -205,7 +206,7 @@
     struct timer *timer;
 
     reply->handle = 0;
-    if ((timer = create_timer( get_req_data(), get_req_data_size(), req->manual )))
+    if ((timer = create_timer( get_req_data(), get_req_data_size(), req->attributes, req->manual )))
     {
         reply->handle = alloc_handle( current->process, timer, req->access,
                                       req->attributes & OBJ_INHERIT );
diff --git a/server/winstation.c b/server/winstation.c
index 91cf703..0b457c4 100644
--- a/server/winstation.c
+++ b/server/winstation.c
@@ -93,7 +93,8 @@
         return NULL;
     }
 
-    if ((winstation = create_named_object( winstation_namespace, &winstation_ops, name, len )))
+    if ((winstation = create_named_object( winstation_namespace, &winstation_ops, name, len,
+                                           OBJ_CASE_INSENSITIVE )))
     {
         if (get_error() != STATUS_OBJECT_NAME_COLLISION)
         {
@@ -182,7 +183,8 @@
 
     if (!(full_name = build_desktop_name( name, len, winstation, &full_len ))) return NULL;
 
-    if ((desktop = create_named_object( winstation_namespace, &desktop_ops, full_name, full_len )))
+    if ((desktop = create_named_object( winstation_namespace, &desktop_ops, full_name, full_len,
+                                        OBJ_CASE_INSENSITIVE )))
     {
         if (get_error() != STATUS_OBJECT_NAME_COLLISION)
         {
@@ -323,7 +325,8 @@
 {
     if (winstation_namespace)
         reply->handle = open_object( winstation_namespace, get_req_data(), get_req_data_size(),
-                                     &winstation_ops, req->access, (req->inherit) ? OBJ_INHERIT:0 );
+                                     &winstation_ops, req->access,
+                                     OBJ_CASE_INSENSITIVE | (req->inherit ? OBJ_INHERIT:0) );
     else
         set_error( STATUS_OBJECT_NAME_NOT_FOUND );
 }
@@ -398,7 +401,7 @@
         {
             reply->handle = open_object( winstation_namespace, full_name, full_len,
                                          &desktop_ops, req->access,
-                                         (req->inherit) ? OBJ_INHERIT:0 );
+                                         OBJ_CASE_INSENSITIVE | (req->inherit ? OBJ_INHERIT:0) );
             free( full_name );
         }
         release_object( winstation );