*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "config.h"
#include <assert.h>
#include <limits.h>
#include <string.h>
+#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
-#include "winbase.h"
+#include "ntstatus.h"
+#define WIN32_NO_STATUS
+#include "windef.h"
+#include "winternl.h"
#include "handle.h"
#include "process.h"
#include "thread.h"
+#include "security.h"
#include "request.h"
struct handle_entry
{
struct object *ptr; /* object */
unsigned int access; /* access rights */
- int fd; /* file descriptor (in client process) */
};
struct handle_table
static struct handle_table *global_table;
/* reserved handle access rights */
-#define RESERVED_SHIFT 25
+#define RESERVED_SHIFT 26
#define RESERVED_INHERIT (HANDLE_FLAG_INHERIT << RESERVED_SHIFT)
#define RESERVED_CLOSE_PROTECT (HANDLE_FLAG_PROTECT_FROM_CLOSE << RESERVED_SHIFT)
#define RESERVED_ALL (RESERVED_INHERIT | RESERVED_CLOSE_PROTECT)
#define MIN_HANDLE_ENTRIES 32
+#define MAX_HANDLE_ENTRIES 0x00ffffff
/* handle to table index conversion */
/* handles are a multiple of 4 under NT; handle 0 is not used */
-inline static obj_handle_t index_to_handle( int index )
+static inline obj_handle_t index_to_handle( int index )
{
return (obj_handle_t)((index + 1) << 2);
}
-inline static int handle_to_index( obj_handle_t handle )
+static inline int handle_to_index( obj_handle_t handle )
{
- return ((unsigned int)handle >> 2) - 1;
+ return (handle >> 2) - 1;
}
/* global handle conversion */
#define HANDLE_OBFUSCATOR 0x544a4def
-inline static int handle_is_global( obj_handle_t handle)
+static inline int handle_is_global( obj_handle_t handle)
{
- return ((unsigned long)handle ^ HANDLE_OBFUSCATOR) < 0x10000;
+ return (handle ^ HANDLE_OBFUSCATOR) <= (MAX_HANDLE_ENTRIES << 2);
}
-inline static obj_handle_t handle_local_to_global( obj_handle_t handle )
+static inline obj_handle_t handle_local_to_global( obj_handle_t handle )
{
if (!handle) return 0;
- return (obj_handle_t)((unsigned long)handle ^ HANDLE_OBFUSCATOR);
+ return handle ^ HANDLE_OBFUSCATOR;
}
-inline static obj_handle_t handle_global_to_local( obj_handle_t handle )
+static inline obj_handle_t handle_global_to_local( obj_handle_t handle )
{
- return (obj_handle_t)((unsigned long)handle ^ HANDLE_OBFUSCATOR);
+ return handle ^ HANDLE_OBFUSCATOR;
}
{
sizeof(struct handle_table), /* size */
handle_table_dump, /* dump */
+ no_get_type, /* get_type */
no_add_queue, /* add_queue */
NULL, /* remove_queue */
NULL, /* signaled */
NULL, /* satisfied */
+ no_signal, /* signal */
no_get_fd, /* get_fd */
+ no_map_access, /* map_access */
+ default_get_sd, /* get_sd */
+ default_set_sd, /* set_sd */
+ no_lookup_name, /* lookup_name */
+ no_open_file, /* open_file */
+ no_close_handle, /* close_handle */
handle_table_destroy /* destroy */
};
for (i = 0; i <= table->last; i++, entry++)
{
if (!entry->ptr) continue;
- fprintf( stderr, "%9u: %p %08x ",
- (unsigned int)index_to_handle(i), entry->ptr, entry->access );
+ fprintf( stderr, " %04x: %p %08x ",
+ index_to_handle(i), entry->ptr, entry->access );
entry->ptr->ops->dump( entry->ptr, 0 );
}
}
{
int i;
struct handle_table *table = (struct handle_table *)obj;
- struct handle_entry *entry = table->entries;
+ struct handle_entry *entry;
assert( obj->ops == &handle_table_ops );
- for (i = 0; i <= table->last; i++, entry++)
+ /* first notify all objects that handles are being closed */
+ if (table->process)
+ {
+ for (i = 0, entry = table->entries; i <= table->last; i++, entry++)
+ {
+ struct object *obj = entry->ptr;
+ if (obj) obj->ops->close_handle( obj, table->process, index_to_handle(i) );
+ }
+ }
+
+ for (i = 0, entry = table->entries; i <= table->last; i++, entry++)
{
struct object *obj = entry->ptr;
entry->ptr = NULL;
static int grow_handle_table( struct handle_table *table )
{
struct handle_entry *new_entries;
- int count = table->count;
+ int count = min( table->count * 2, MAX_HANDLE_ENTRIES );
- if (count >= INT_MAX / 2) return 0;
- count *= 2;
- if (!(new_entries = realloc( table->entries, count * sizeof(struct handle_entry) )))
+ if (count == table->count ||
+ !(new_entries = realloc( table->entries, count * sizeof(struct handle_entry) )))
{
- set_error( STATUS_NO_MEMORY );
+ set_error( STATUS_INSUFFICIENT_RESOURCES );
return 0;
}
table->entries = new_entries;
table->free = i + 1;
entry->ptr = grab_object( obj );
entry->access = access;
- entry->fd = -1;
return index_to_handle(i);
}
/* allocate a handle for an object, incrementing its refcount */
/* return the handle, or 0 on error */
-obj_handle_t alloc_handle( struct process *process, void *obj, unsigned int access, int inherit )
+obj_handle_t alloc_handle_no_access_check( struct process *process, void *ptr, unsigned int access, unsigned int attr )
{
- struct handle_table *table = process->handles;
+ struct object *obj = ptr;
+
+ access &= ~RESERVED_ALL;
+ if (attr & OBJ_INHERIT) access |= RESERVED_INHERIT;
+ if (!process->handles)
+ {
+ set_error( STATUS_NO_MEMORY );
+ return 0;
+ }
+ return alloc_entry( process->handles, obj, access );
+}
- assert( table );
- assert( !(access & RESERVED_ALL) );
- if (inherit) access |= RESERVED_INHERIT;
- return alloc_entry( table, obj, access );
+/* allocate a handle for an object, checking the dacl allows the process to */
+/* access it and incrementing its refcount */
+/* return the handle, or 0 on error */
+obj_handle_t alloc_handle( struct process *process, void *ptr, unsigned int access, unsigned int attr )
+{
+ struct object *obj = ptr;
+ access = obj->ops->map_access( obj, access );
+ if (access && !check_object_access( obj, &access )) return 0;
+ return alloc_handle_no_access_check( process, ptr, access, attr );
}
/* allocate a global handle for an object, incrementing its refcount */
/* return the handle, or 0 on error */
-static obj_handle_t alloc_global_handle( void *obj, unsigned int access )
+static obj_handle_t alloc_global_handle_no_access_check( void *obj, unsigned int access )
{
if (!global_table)
{
if (!(global_table = (struct handle_table *)alloc_handle_table( NULL, 0 )))
return 0;
+ make_object_static( &global_table->obj );
}
return handle_local_to_global( alloc_entry( global_table, obj, access ));
}
+/* allocate a global handle for an object, checking the dacl allows the */
+/* process to access it and incrementing its refcount and incrementing its refcount */
+/* return the handle, or 0 on error */
+static obj_handle_t alloc_global_handle( void *obj, unsigned int access )
+{
+ if (access && !check_object_access( obj, &access )) return 0;
+ return alloc_global_handle_no_access_check( obj, access );
+}
+
/* return a handle entry, or NULL if the handle is invalid */
static struct handle_entry *get_handle( struct process *process, obj_handle_t handle )
{
handle = handle_global_to_local(handle);
table = global_table;
}
- if (!table) goto error;
+ if (!table) return NULL;
index = handle_to_index( handle );
- if (index < 0) goto error;
- if (index > table->last) goto error;
+ if (index < 0) return NULL;
+ if (index > table->last) return NULL;
entry = table->entries + index;
- if (!entry->ptr) goto error;
+ if (!entry->ptr) return NULL;
return entry;
-
- error:
- set_error( STATUS_INVALID_HANDLE );
- return NULL;
}
/* attempt to shrink a table */
for (i = 0; i <= table->last; i++, ptr++)
{
if (!ptr->ptr) continue;
- ptr->fd = -1;
if (ptr->access & RESERVED_INHERIT) grab_object( ptr->ptr );
else ptr->ptr = NULL; /* don't inherit this entry */
}
}
/* close a handle and decrement the refcount of the associated object */
-/* return 1 if OK, 0 on error */
-int close_handle( struct process *process, obj_handle_t handle, int *fd )
+unsigned int close_handle( struct process *process, obj_handle_t handle )
{
struct handle_table *table;
struct handle_entry *entry;
struct object *obj;
- if (!(entry = get_handle( process, handle ))) return 0;
- if (entry->access & RESERVED_CLOSE_PROTECT)
- {
- set_error( STATUS_INVALID_HANDLE );
- return 0;
- }
+ if (!(entry = get_handle( process, handle ))) return STATUS_INVALID_HANDLE;
+ if (entry->access & RESERVED_CLOSE_PROTECT) return STATUS_HANDLE_NOT_CLOSABLE;
obj = entry->ptr;
+ if (!obj->ops->close_handle( obj, process, handle )) return STATUS_HANDLE_NOT_CLOSABLE;
entry->ptr = NULL;
- if (fd) *fd = entry->fd;
- else if (entry->fd != -1) return 1; /* silently ignore close attempt if we cannot close the fd */
- entry->fd = -1;
table = handle_is_global(handle) ? global_table : process->handles;
if (entry < table->entries + table->free) table->free = entry - table->entries;
if (entry == table->entries + table->last) shrink_handle_table( table );
- /* hack: windows seems to treat registry handles differently */
- registry_close_handle( obj, handle );
release_object( obj );
- return 1;
-}
-
-/* close all the global handles */
-void close_global_handles(void)
-{
- if (global_table)
- {
- release_object( global_table );
- global_table = NULL;
- }
+ return STATUS_SUCCESS;
}
/* retrieve the object corresponding to one of the magic pseudo-handles */
static inline struct object *get_magic_handle( obj_handle_t handle )
{
- switch((unsigned long)handle)
+ switch(handle)
{
case 0xfffffffe: /* current thread pseudo-handle */
return ¤t->obj;
if (!(obj = get_magic_handle( handle )))
{
- if (!(entry = get_handle( process, handle ))) return NULL;
+ if (!(entry = get_handle( process, handle )))
+ {
+ set_error( STATUS_INVALID_HANDLE );
+ return NULL;
+ }
if ((entry->access & access) != access)
{
set_error( STATUS_ACCESS_DENIED );
return grab_object( obj );
}
-/* retrieve the cached fd for a given handle */
-int get_handle_unix_fd( struct process *process, obj_handle_t handle, unsigned int access )
+/* retrieve the access rights of a given handle */
+unsigned int get_handle_access( struct process *process, obj_handle_t handle )
{
struct handle_entry *entry;
- if (!(entry = get_handle( process, handle ))) return -1;
- if ((entry->access & access) != access)
- {
- set_error( STATUS_ACCESS_DENIED );
- return -1;
- }
- return entry->fd;
+ if (get_magic_handle( handle )) return ~RESERVED_ALL; /* magic handles have all access rights */
+ if (!(entry = get_handle( process, handle ))) return 0;
+ return entry->access & ~RESERVED_ALL;
}
/* find the first inherited handle of the given type */
return 0;
}
+/* enumerate handles of a given type */
+/* this is needed for window stations and desktops */
+obj_handle_t enumerate_handles( struct process *process, const struct object_ops *ops,
+ unsigned int *index )
+{
+ struct handle_table *table = process->handles;
+ unsigned int i;
+ struct handle_entry *entry;
+
+ if (!table) return 0;
+
+ for (i = *index, entry = &table->entries[i]; i <= table->last; i++, entry++)
+ {
+ if (!entry->ptr) continue;
+ if (entry->ptr->ops != ops) continue;
+ *index = i + 1;
+ return index_to_handle(i);
+ }
+ return 0;
+}
+
/* get/set the handle reserved flags */
/* return the old flags (or -1 on error) */
-int set_handle_info( struct process *process, obj_handle_t handle, int mask, int flags, int *fd )
+static int set_handle_flags( struct process *process, obj_handle_t handle, int mask, int flags )
{
struct handle_entry *entry;
unsigned int old_access;
if (mask) set_error( STATUS_ACCESS_DENIED );
return 0;
}
- if (!(entry = get_handle( process, handle ))) return -1;
+ if (!(entry = get_handle( process, handle )))
+ {
+ set_error( STATUS_INVALID_HANDLE );
+ return -1;
+ }
old_access = entry->access;
mask = (mask << RESERVED_SHIFT) & RESERVED_ALL;
flags = (flags << RESERVED_SHIFT) & mask;
entry->access = (entry->access & ~mask) | flags;
- /* if no current fd set it, otherwise return current fd */
- if (entry->fd == -1) entry->fd = *fd;
- *fd = entry->fd;
return (old_access & RESERVED_ALL) >> RESERVED_SHIFT;
}
/* duplicate a handle */
obj_handle_t duplicate_handle( struct process *src, obj_handle_t src_handle, struct process *dst,
- unsigned int access, int inherit, int options )
+ unsigned int access, unsigned int attr, unsigned int options )
{
obj_handle_t res;
+ struct handle_entry *entry;
+ unsigned int src_access;
struct object *obj = get_handle_obj( src, src_handle, 0, NULL );
if (!obj) return 0;
+ if ((entry = get_handle( src, src_handle )))
+ src_access = entry->access;
+ else /* pseudo-handle, give it full access */
+ src_access = obj->ops->map_access( obj, GENERIC_ALL );
+ src_access &= ~RESERVED_ALL;
+
if (options & DUP_HANDLE_SAME_ACCESS)
+ access = src_access;
+ else
+ access = obj->ops->map_access( obj, access ) & ~RESERVED_ALL;
+
+ /* asking for the more access rights than src_access? */
+ if (access & ~src_access)
{
- struct handle_entry *entry = get_handle( src, src_handle );
- if (entry)
- access = entry->access;
- else /* pseudo-handle, give it full access */
- {
- access = STANDARD_RIGHTS_ALL | SPECIFIC_RIGHTS_ALL;
- clear_error();
- }
+ if (options & DUP_HANDLE_MAKE_GLOBAL)
+ res = alloc_global_handle( obj, access );
+ else
+ res = alloc_handle( dst, obj, access, attr );
}
- access &= ~RESERVED_ALL;
- if (options & DUP_HANDLE_MAKE_GLOBAL)
- res = alloc_global_handle( obj, access );
else
- res = alloc_handle( dst, obj, access, inherit );
+ {
+ if (options & DUP_HANDLE_MAKE_GLOBAL)
+ res = alloc_global_handle_no_access_check( obj, access );
+ else
+ res = alloc_handle_no_access_check( dst, obj, access, attr );
+ }
+
release_object( obj );
return res;
}
/* open a new handle to an existing object */
-obj_handle_t open_object( const struct namespace *namespace, const WCHAR *name, size_t len,
- const struct object_ops *ops, unsigned int access, int inherit )
+obj_handle_t open_object( const struct namespace *namespace, const struct unicode_str *name,
+ 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, attr );
if (obj)
{
if (ops && obj->ops != ops)
set_error( STATUS_OBJECT_TYPE_MISMATCH );
else
- handle = alloc_handle( current->process, obj, access, inherit );
+ handle = alloc_handle( current->process, obj, access, attr );
release_object( obj );
}
else
return handle;
}
+/* return the size of the handle table of a given process */
+unsigned int get_handle_table_count( struct process *process )
+{
+ if (!process->handles) return 0;
+ return process->handles->count;
+}
+
/* close a handle */
DECL_HANDLER(close_handle)
{
- close_handle( current->process, req->handle, &reply->fd );
+ unsigned int err = close_handle( current->process, req->handle );
+ set_error( err );
}
/* set a handle information */
DECL_HANDLER(set_handle_info)
{
- int fd = req->fd;
-
- if (handle_is_global(req->handle)) fd = -1; /* no fd cache for global handles */
- reply->old_flags = set_handle_info( current->process, req->handle,
- req->mask, req->flags, &fd );
- reply->cur_fd = fd;
+ reply->old_flags = set_handle_flags( current->process, req->handle, req->mask, req->flags );
}
/* duplicate a handle */
struct process *src, *dst;
reply->handle = 0;
- reply->fd = -1;
if ((src = get_process_from_handle( req->src_process, PROCESS_DUP_HANDLE )))
{
if (req->options & DUP_HANDLE_MAKE_GLOBAL)
{
reply->handle = duplicate_handle( src, req->src_handle, NULL,
- req->access, req->inherit, req->options );
+ req->access, req->attributes, req->options );
}
else if ((dst = get_process_from_handle( req->dst_process, PROCESS_DUP_HANDLE )))
{
reply->handle = duplicate_handle( src, req->src_handle, dst,
- req->access, req->inherit, req->options );
+ req->access, req->attributes, req->options );
release_object( dst );
}
/* close the handle no matter what happened */
- if (req->options & DUP_HANDLE_CLOSE_SOURCE)
+ if (req->options & DUP_HANDLE_CLOSE_SOURCE) reply->closed = !close_handle( src, req->src_handle );
+ reply->self = (src == current->process);
+ release_object( src );
+ }
+}
+
+DECL_HANDLER(get_object_info)
+{
+ struct object *obj;
+ WCHAR *name;
+
+ if (!(obj = get_handle_obj( current->process, req->handle, 0, NULL ))) return;
+
+ reply->access = get_handle_access( current->process, req->handle );
+ reply->ref_count = obj->refcount;
+ if ((name = get_object_full_name( obj, &reply->total )))
+ set_reply_data_ptr( name, min( reply->total, get_reply_max_size() ));
+ release_object( obj );
+}
+
+DECL_HANDLER(set_security_object)
+{
+ data_size_t sd_size = get_req_data_size();
+ const struct security_descriptor *sd = get_req_data();
+ struct object *obj;
+ unsigned int access = 0;
+
+ if (!sd_is_valid( sd, sd_size ))
+ {
+ set_error( STATUS_ACCESS_VIOLATION );
+ return;
+ }
+
+ if (req->security_info & OWNER_SECURITY_INFORMATION ||
+ req->security_info & GROUP_SECURITY_INFORMATION)
+ access |= WRITE_OWNER;
+ if (req->security_info & SACL_SECURITY_INFORMATION)
+ access |= ACCESS_SYSTEM_SECURITY;
+ if (req->security_info & DACL_SECURITY_INFORMATION)
+ access |= WRITE_DAC;
+
+ if (!(obj = get_handle_obj( current->process, req->handle, access, NULL ))) return;
+
+ obj->ops->set_sd( obj, sd, req->security_info );
+ release_object( obj );
+}
+
+DECL_HANDLER(get_security_object)
+{
+ const struct security_descriptor *sd;
+ struct object *obj;
+ unsigned int access = READ_CONTROL;
+ struct security_descriptor req_sd;
+ int present;
+ const SID *owner, *group;
+ const ACL *sacl, *dacl;
+
+ if (req->security_info & SACL_SECURITY_INFORMATION)
+ access |= ACCESS_SYSTEM_SECURITY;
+
+ if (!(obj = get_handle_obj( current->process, req->handle, access, NULL ))) return;
+
+ sd = obj->ops->get_sd( obj );
+ if (sd)
+ {
+ req_sd.control = sd->control & ~SE_SELF_RELATIVE;
+
+ owner = sd_get_owner( sd );
+ if (req->security_info & OWNER_SECURITY_INFORMATION)
+ req_sd.owner_len = sd->owner_len;
+ else
+ req_sd.owner_len = 0;
+
+ group = sd_get_group( sd );
+ if (req->security_info & GROUP_SECURITY_INFORMATION)
+ req_sd.group_len = sd->group_len;
+ else
+ req_sd.group_len = 0;
+
+ req_sd.control |= SE_SACL_PRESENT;
+ sacl = sd_get_sacl( sd, &present );
+ if (req->security_info & SACL_SECURITY_INFORMATION && present)
+ req_sd.sacl_len = sd->sacl_len;
+ else
+ req_sd.sacl_len = 0;
+
+ req_sd.control |= SE_DACL_PRESENT;
+ dacl = sd_get_dacl( sd, &present );
+ if (req->security_info & DACL_SECURITY_INFORMATION && present)
+ req_sd.dacl_len = sd->dacl_len;
+ else
+ req_sd.dacl_len = 0;
+
+ reply->sd_len = sizeof(req_sd) + req_sd.owner_len + req_sd.group_len +
+ req_sd.sacl_len + req_sd.dacl_len;
+ if (reply->sd_len <= get_reply_max_size())
{
- if (src == current->process) close_handle( src, req->src_handle, &reply->fd );
- else close_handle( src, req->src_handle, NULL );
+ char *ptr = set_reply_data_size(reply->sd_len);
+
+ memcpy( ptr, &req_sd, sizeof(req_sd) );
+ ptr += sizeof(req_sd);
+ memcpy( ptr, owner, req_sd.owner_len );
+ ptr += req_sd.owner_len;
+ memcpy( ptr, group, req_sd.group_len );
+ ptr += req_sd.group_len;
+ memcpy( ptr, sacl, req_sd.sacl_len );
+ ptr += req_sd.sacl_len;
+ memcpy( ptr, dacl, req_sd.dacl_len );
}
- release_object( src );
+ else
+ set_error(STATUS_BUFFER_TOO_SMALL);
}
+
+ release_object( obj );
}