reactos/wine
1
0
Fork 0
mirror of https://github.com/reactos/wine.git synced 2024-11-28 14:10:32 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Pass object attributes to create_named_object & find_object.

Browse Source
This commit is contained in:
Vitaliy Margolen 2005-10-29 12:38:23 +00:00 committed by Alexandre Julliard
parent 289889c9ec
commit 3585f2fa77
13 changed files with 53 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
server/console.c
View File

@ -227,7 +227,7 @@ static struct object *create_console_input( struct thread* renderer )
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)
{

6
server/event.c
View File

@ -59,12 +59,12 @@ static const struct object_ops event_ops =
};
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 @@ DECL_HANDLER(create_event)
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,

2
server/handle.c
View File

@ -525,7 +525,7 @@ obj_handle_t open_object( const struct namespace *namespace, const WCHAR *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, len, attr );
if (obj)
{
if (ops && obj->ops != ops)

14
server/mailslot.c
View File

@ -213,8 +213,8 @@ static void mailslot_queue_async( struct fd *fd, void *apc, void *user,
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 @@ static struct mailslot *create_mailslot( const WCHAR *name, size_t len, int max_
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 @@ static struct mailslot *create_mailslot( const WCHAR *name, size_t len, int max_
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 @@ DECL_HANDLER(create_mailslot)
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 @@ DECL_HANDLER(open_mailslot)
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;

10
server/mapping.c
View File

@ -270,15 +270,15 @@ inline static int get_file_size( struct file *file, file_pos_t *size )
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 @@ DECL_HANDLER(create_mapping)
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 );

8
server/mutex.c
View File

@ -62,11 +62,12 @@ static const struct object_ops mutex_ops =
};
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 @@ DECL_HANDLER(create_mutex)
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 );

16
server/named_pipe.c
View File

@ -397,7 +397,7 @@ static int pipe_server_flush( struct fd *fd, struct event **event )
/* 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 @@ static int pipe_client_get_info( struct fd *fd )
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 @@ static struct named_pipe *create_named_pipe( const WCHAR *name, size_t len )
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 @@ DECL_HANDLER(create_named_pipe)
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 @@ DECL_HANDLER(open_named_pipe)
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 @@ DECL_HANDLER(wait_named_pipe)
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;

7
server/object.c
View File

@ -157,14 +157,14 @@ void *alloc_object( const struct object_ops *ops )
}
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 @@ void release_object( void *ptr )
}
/* 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;

7
server/object.h
View File

@ -94,13 +94,14 @@ extern void *alloc_object( const struct object_ops *ops );
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 @@ extern void dump_objects(void);
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 );

2
server/process.c
View File

@ -993,7 +993,7 @@ DECL_HANDLER(init_process_done)
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 );
}

6
server/semaphore.c
View File

@ -59,7 +59,7 @@ static const struct object_ops semaphore_ops =
};
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 @@ static struct semaphore *create_semaphore( const WCHAR *name, size_t len,
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 @@ DECL_HANDLER(create_semaphore)
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,

7
server/timer.c
View File

@ -68,11 +68,12 @@ static const struct object_ops timer_ops =
/* 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 @@ DECL_HANDLER(create_timer)
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 );

11
server/winstation.c
View File

@ -93,7 +93,8 @@ static struct winstation *create_winstation( const WCHAR *name, size_t len, unsi
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 @@ static struct desktop *create_desktop( const WCHAR *name, size_t len, unsigned i
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 @@ DECL_HANDLER(open_winstation)
{
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 @@ DECL_HANDLER(open_desktop)
{
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 );