static struct semaphore *create_semaphore( struct directory *root, const struct unicode_str *name,
unsigned int attr, unsigned int initial, unsigned int max,
const struct security_descriptor *sd )
{
struct semaphore *sem;
if (!max || (initial > max))
{
set_error( STATUS_INVALID_PARAMETER );
return NULL;
}
if ((sem = create_named_object_dir( root, name, attr, &semaphore_ops )))
{
if (get_error() != STATUS_OBJECT_NAME_EXISTS)
{
/* initialize it if it didn't already exist */
sem->count = initial;
sem->max = max;
if (sd) default_set_sd( &sem->obj, sd, OWNER_SECURITY_INFORMATION|
GROUP_SECURITY_INFORMATION|
DACL_SECURITY_INFORMATION|
SACL_SECURITY_INFORMATION );
}
}
return sem;
}
struct symlink *create_symlink( struct directory *root, const struct unicode_str *name,
unsigned int attr, const struct unicode_str *target,
const struct security_descriptor *sd )
{
struct symlink *symlink;
if (!target->len)
{
set_error( STATUS_INVALID_PARAMETER );
return NULL;
}
if ((symlink = create_named_object_dir( root, name, attr, &symlink_ops )) &&
(get_error() != STATUS_OBJECT_NAME_EXISTS))
{
if ((symlink->target = memdup( target->str, target->len )))
{
symlink->len = target->len;
if (sd)
default_set_sd( &symlink->obj, sd,
OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION |
DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION );
}
else
{
release_object( symlink );
symlink = NULL;
}
}
return symlink;
}
/* create a winstation object */
static struct winstation *create_winstation( struct directory *root, const struct unicode_str *name,
unsigned int attr, unsigned int flags )
{
struct winstation *winstation;
if (memchrW( name->str, '\\', name->len / sizeof(WCHAR) )) /* no backslash allowed in name */
{
set_error( STATUS_INVALID_PARAMETER );
return NULL;
}
if ((winstation = create_named_object_dir( root, name, attr, &winstation_ops )))
{
if (get_error() != STATUS_OBJECT_NAME_EXISTS)
{
/* initialize it if it didn't already exist */
winstation->flags = flags;
winstation->clipboard = NULL;
winstation->atom_table = NULL;
list_add_tail( &winstation_list, &winstation->entry );
list_init( &winstation->desktops );
if (!(winstation->desktop_names = create_namespace( 7 )))
{
release_object( winstation );
return NULL;
}
}
}
return winstation;
}
struct device *create_unix_device( struct directory *root, const struct unicode_str *name,
const char *unix_path )
{
struct device *device;
if ((device = create_named_object_dir( root, name, 0, &device_ops )))
{
device->unix_path = strdup( unix_path );
device->manager = NULL; /* no manager, requests go straight to the Unix device */
list_init( &device->files );
make_object_static( &device->obj );
}
return device;
}
static struct uk_completion *create_completion(struct directory *root,
const struct unicode_str *name, unsigned int attr, unsigned int concurrent)
{
struct uk_completion *completion;
if ((completion = create_named_object_dir(root, name, attr, &completion_ops))) {
if (get_error() != STATUS_OBJECT_NAME_EXISTS) {
INIT_DISP_HEADER(&completion->obj.header, COMPLETION,
sizeof(struct completion) / sizeof(ULONG), 0);
INIT_LIST_HEAD(&completion->queue);
completion->depth = 0;
}
}
return completion;
}
static struct device *create_device( struct directory *root, const struct unicode_str *name,
struct device_manager *manager, unsigned int attr )
{
struct device *device;
if ((device = create_named_object_dir( root, name, attr, &device_ops )))
{
if (get_error() != STATUS_OBJECT_NAME_EXISTS)
{
/* initialize it if it didn't already exist */
device->unix_path = NULL;
device->manager = manager;
list_add_tail( &manager->devices, &device->entry );
list_init( &device->files );
}
}
return device;
}
struct keyed_event *create_keyed_event( struct directory *root, const struct unicode_str *name,
unsigned int attr, const struct security_descriptor *sd )
{
struct keyed_event *event;
if ((event = create_named_object_dir( root, name, attr, &keyed_event_ops )))
{
if (get_error() != STATUS_OBJECT_NAME_EXISTS)
{
/* initialize it if it didn't already exist */
if (sd) default_set_sd( &event->obj, sd, OWNER_SECURITY_INFORMATION|
GROUP_SECURITY_INFORMATION|
DACL_SECURITY_INFORMATION|
SACL_SECURITY_INFORMATION );
}
}
return event;
}
static struct device *create_device(HANDLE root, const struct unicode_str *name,
struct device_manager *manager, unsigned int attr)
{
struct device *device;
if ((device = create_named_object_dir(root, name, attr, &device_ops))) {
if (get_error() != STATUS_OBJECT_NAME_EXISTS) {
/* initialize it if it didn't already exist */
device->manager = manager;
list_add_before(&manager->devices, &device->entry);
INIT_LIST_HEAD(&device->requests);
if (!(device->fd = alloc_pseudo_fd(&device_fd_ops, &device->obj, 0))) {
release_object(device);
device = NULL;
}
}
}
return device;
}
/* create a timer object */
static struct timer *create_timer( struct directory *root, const struct unicode_str *name,
unsigned int attr, int manual )
{
struct timer *timer;
if ((timer = create_named_object_dir( root, name, attr, &timer_ops )))
{
if (get_error() != STATUS_OBJECT_NAME_EXISTS)
{
/* initialize it if it didn't already exist */
timer->manual = manual;
timer->signaled = 0;
timer->when = 0;
timer->period = 0;
timer->timeout = NULL;
timer->thread = NULL;
}
}
return timer;
}
static struct mutex *create_mutex( struct directory *root, const struct unicode_str *name,
unsigned int attr, int owned, const struct security_descriptor *sd )
{
struct mutex *mutex;
if ((mutex = create_named_object_dir( root, name, attr, &mutex_ops )))
{
if (get_error() != STATUS_OBJECT_NAME_EXISTS)
{
/* initialize it if it didn't already exist */
mutex->count = 0;
mutex->owner = NULL;
mutex->abandoned = 0;
if (owned) do_grab( mutex, current );
if (sd) default_set_sd( &mutex->obj, sd, OWNER_SECURITY_INFORMATION|
GROUP_SECURITY_INFORMATION|
DACL_SECURITY_INFORMATION|
SACL_SECURITY_INFORMATION );
}
}
return mutex;
}
struct symlink *create_symlink( struct directory *root, const struct unicode_str *name,
unsigned int attr, const struct unicode_str *target )
{
struct symlink *symlink;
if (!target->len)
{
set_error( STATUS_INVALID_PARAMETER );
return NULL;
}
if ((symlink = create_named_object_dir( root, name, attr, &symlink_ops )) &&
(get_error() != STATUS_OBJECT_NAME_EXISTS))
{
if ((symlink->target = memdup( target->str, target->len )))
symlink->len = target->len;
else
{
release_object( symlink );
symlink = NULL;
}
}
return symlink;
}
static struct object *create_mapping( struct directory *root, const struct unicode_str *name,
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_dir( root, name, attr, &mapping_ops )))
return NULL;
if (get_error() == STATUS_OBJECT_NAME_EXISTS)
return &mapping->obj; /* Nothing else to do */
mapping->header_size = 0;
mapping->base = NULL;
mapping->shared_file = NULL;
mapping->shared_size = 0;
if (protect & VPROT_READ) access |= FILE_READ_DATA;
if (protect & VPROT_WRITE) access |= FILE_WRITE_DATA;
if (handle)
{
if (!(mapping->file = get_file_obj( current->process, handle, access ))) goto error;
if (protect & VPROT_IMAGE)
{
if (!get_image_params( mapping )) goto error;
return &mapping->obj;
}
if (!size)
{
if (!get_file_size( mapping->file, &size )) goto error;
if (!size)
{
set_error( STATUS_MAPPED_FILE_SIZE_ZERO );
goto error;
}
}
else
{
if (!grow_file( mapping->file, size )) goto error;
}
}
else /* Anonymous mapping (no associated file) */
{
if (!size || (protect & VPROT_IMAGE))
{
set_error( STATUS_INVALID_PARAMETER );
mapping->file = NULL;
goto error;
}
if (!(mapping->file = create_temp_file( access ))) goto error;
if (!grow_file( mapping->file, size )) goto error;
}
mapping->size = (size + page_mask) & ~((file_pos_t)page_mask);
mapping->protect = protect;
return &mapping->obj;
error:
release_object( mapping );
return NULL;
}
