winstation.c 23.3 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
/*
 * Server-side window stations and desktops handling
 *
 * Copyright (C) 2002, 2005 Alexandre Julliard
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
18
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 20 21 22 23 24 25 26
 */

#include "config.h"
#include "wine/port.h"

#include <stdio.h>
#include <stdarg.h>

27 28
#include "ntstatus.h"
#define WIN32_NO_STATUS
29 30 31
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
32
#include "winternl.h"
33 34 35 36 37

#include "object.h"
#include "handle.h"
#include "request.h"
#include "process.h"
38
#include "user.h"
39
#include "file.h"
40
#include "security.h"
41 42 43 44 45 46 47
#include "wine/unicode.h"


static struct list winstation_list = LIST_INIT(winstation_list);
static struct namespace *winstation_namespace;

static void winstation_dump( struct object *obj, int verbose );
48
static struct object_type *winstation_get_type( struct object *obj );
49
static int winstation_close_handle( struct object *obj, struct process *process, obj_handle_t handle );
50
static void winstation_destroy( struct object *obj );
51
static unsigned int winstation_map_access( struct object *obj, unsigned int access );
52
static void desktop_dump( struct object *obj, int verbose );
53
static struct object_type *desktop_get_type( struct object *obj );
54
static int desktop_close_handle( struct object *obj, struct process *process, obj_handle_t handle );
55
static void desktop_destroy( struct object *obj );
56
static unsigned int desktop_map_access( struct object *obj, unsigned int access );
57 58 59 60 61

static const struct object_ops winstation_ops =
{
    sizeof(struct winstation),    /* size */
    winstation_dump,              /* dump */
62
    winstation_get_type,          /* get_type */
63 64 65 66 67 68
    no_add_queue,                 /* add_queue */
    NULL,                         /* remove_queue */
    NULL,                         /* signaled */
    NULL,                         /* satisfied */
    no_signal,                    /* signal */
    no_get_fd,                    /* get_fd */
69
    winstation_map_access,        /* map_access */
70 71
    default_get_sd,               /* get_sd */
    default_set_sd,               /* set_sd */
72
    no_lookup_name,               /* lookup_name */
73
    no_open_file,                 /* open_file */
74
    winstation_close_handle,      /* close_handle */
75 76 77 78 79 80 81 82
    winstation_destroy            /* destroy */
};


static const struct object_ops desktop_ops =
{
    sizeof(struct desktop),       /* size */
    desktop_dump,                 /* dump */
83
    desktop_get_type,             /* get_type */
84 85 86 87 88 89
    no_add_queue,                 /* add_queue */
    NULL,                         /* remove_queue */
    NULL,                         /* signaled */
    NULL,                         /* satisfied */
    no_signal,                    /* signal */
    no_get_fd,                    /* get_fd */
90
    desktop_map_access,           /* map_access */
91 92
    default_get_sd,               /* get_sd */
    default_set_sd,               /* set_sd */
93
    no_lookup_name,               /* lookup_name */
94
    no_open_file,                 /* open_file */
95
    desktop_close_handle,         /* close_handle */
96 97 98 99 100 101
    desktop_destroy               /* destroy */
};

#define DESKTOP_ALL_ACCESS 0x01ff

/* create a winstation object */
102 103
static struct winstation *create_winstation( const struct unicode_str *name, unsigned int attr,
                                             unsigned int flags )
104 105 106
{
    struct winstation *winstation;

107
    if (!winstation_namespace && !(winstation_namespace = create_namespace( 7 )))
108 109
        return NULL;

110
    if (memchrW( name->str, '\\', name->len / sizeof(WCHAR) ))  /* no backslash allowed in name */
111 112 113 114 115
    {
        set_error( STATUS_INVALID_PARAMETER );
        return NULL;
    }

116
    if ((winstation = create_named_object( winstation_namespace, &winstation_ops, name, attr )))
117
    {
118
        if (get_error() != STATUS_OBJECT_NAME_EXISTS)
119 120 121
        {
            /* initialize it if it didn't already exist */
            winstation->flags = flags;
122
            winstation->clipboard = NULL;
123
            winstation->atom_table = NULL;
124 125 126 127 128 129 130 131 132 133 134
            list_add_tail( &winstation_list, &winstation->entry );
            list_init( &winstation->desktops );
        }
    }
    return winstation;
}

static void winstation_dump( struct object *obj, int verbose )
{
    struct winstation *winstation = (struct winstation *)obj;

135 136
    fprintf( stderr, "Winstation flags=%x clipboard=%p atoms=%p ",
             winstation->flags, winstation->clipboard, winstation->atom_table );
137 138 139 140
    dump_object_name( &winstation->obj );
    fputc( '\n', stderr );
}

141 142 143 144 145 146 147
static struct object_type *winstation_get_type( struct object *obj )
{
    static const WCHAR name[] = {'W','i','n','d','o','w','S','t','a','t','i','o','n'};
    static const struct unicode_str str = { name, sizeof(name) };
    return get_object_type( &str );
}

148 149 150 151 152
static int winstation_close_handle( struct object *obj, struct process *process, obj_handle_t handle )
{
    return (process->winstation != handle);
}

153 154 155 156 157
static void winstation_destroy( struct object *obj )
{
    struct winstation *winstation = (struct winstation *)obj;

    list_remove( &winstation->entry );
158
    if (winstation->clipboard) release_object( winstation->clipboard );
159
    if (winstation->atom_table) release_object( winstation->atom_table );
160 161
}

162 163 164 165 166 167 168 169 170 171 172
static unsigned int winstation_map_access( struct object *obj, unsigned int access )
{
    if (access & GENERIC_READ)    access |= STANDARD_RIGHTS_READ | WINSTA_ENUMDESKTOPS | WINSTA_READATTRIBUTES |
                                            WINSTA_ENUMERATE | WINSTA_READSCREEN;
    if (access & GENERIC_WRITE)   access |= STANDARD_RIGHTS_WRITE | WINSTA_ACCESSCLIPBOARD | WINSTA_CREATEDESKTOP |
                                            WINSTA_WRITEATTRIBUTES;
    if (access & GENERIC_EXECUTE) access |= STANDARD_RIGHTS_EXECUTE | WINSTA_ACCESSGLOBALATOMS | WINSTA_EXITWINDOWS;
    if (access & GENERIC_ALL)     access |= STANDARD_RIGHTS_REQUIRED | WINSTA_ALL_ACCESS;
    return access & ~(GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | GENERIC_ALL);
}

173
/* retrieve the process window station, checking the handle access rights */
174
struct winstation *get_process_winstation( struct process *process, unsigned int access )
175 176 177 178 179 180
{
    return (struct winstation *)get_handle_obj( process, process->winstation,
                                                access, &winstation_ops );
}

/* build the full name of a desktop object */
181 182
static WCHAR *build_desktop_name( const struct unicode_str *name,
                                  struct winstation *winstation, struct unicode_str *res )
183 184 185
{
    const WCHAR *winstation_name;
    WCHAR *full_name;
186
    data_size_t winstation_len;
187

188
    if (memchrW( name->str, '\\', name->len / sizeof(WCHAR) ))
189 190 191 192 193 194 195 196
    {
        set_error( STATUS_INVALID_PARAMETER );
        return NULL;
    }

    if (!(winstation_name = get_object_name( &winstation->obj, &winstation_len )))
        winstation_len = 0;

197 198
    res->len = winstation_len + name->len + sizeof(WCHAR);
    if (!(full_name = mem_alloc( res->len ))) return NULL;
199 200
    memcpy( full_name, winstation_name, winstation_len );
    full_name[winstation_len / sizeof(WCHAR)] = '\\';
201 202
    memcpy( full_name + winstation_len / sizeof(WCHAR) + 1, name->str, name->len );
    res->str = full_name;
203 204 205
    return full_name;
}

206
/* retrieve a pointer to a desktop object */
207
struct desktop *get_desktop_obj( struct process *process, obj_handle_t handle, unsigned int access )
208 209 210 211
{
    return (struct desktop *)get_handle_obj( process, handle, access, &desktop_ops );
}

212
/* create a desktop object */
213 214
static struct desktop *create_desktop( const struct unicode_str *name, unsigned int attr,
                                       unsigned int flags, struct winstation *winstation )
215 216
{
    struct desktop *desktop;
217
    struct unicode_str full_str;
218 219
    WCHAR *full_name;

220
    if (!(full_name = build_desktop_name( name, winstation, &full_str ))) return NULL;
221

222
    if ((desktop = create_named_object( winstation_namespace, &desktop_ops, &full_str, attr )))
223
    {
224
        if (get_error() != STATUS_OBJECT_NAME_EXISTS)
225 226 227 228
        {
            /* initialize it if it didn't already exist */
            desktop->flags = flags;
            desktop->winstation = (struct winstation *)grab_object( winstation );
229
            desktop->top_window = NULL;
230
            desktop->msg_window = NULL;
231
            desktop->global_hooks = NULL;
232
            desktop->close_timeout = NULL;
233
            desktop->foreground_input = NULL;
234
            desktop->users = 0;
235
            memset( &desktop->cursor, 0, sizeof(desktop->cursor) );
236
            memset( desktop->keystate, 0, sizeof(desktop->keystate) );
237
            list_add_tail( &winstation->desktops, &desktop->entry );
238
            list_init( &desktop->hotkeys );
239 240 241 242 243 244 245 246 247 248
        }
    }
    free( full_name );
    return desktop;
}

static void desktop_dump( struct object *obj, int verbose )
{
    struct desktop *desktop = (struct desktop *)obj;

249 250
    fprintf( stderr, "Desktop flags=%x winstation=%p top_win=%p hooks=%p ",
             desktop->flags, desktop->winstation, desktop->top_window, desktop->global_hooks );
251 252 253 254
    dump_object_name( &desktop->obj );
    fputc( '\n', stderr );
}

255 256 257 258 259 260 261
static struct object_type *desktop_get_type( struct object *obj )
{
    static const WCHAR name[] = {'D','e','s','k','t','o','p'};
    static const struct unicode_str str = { name, sizeof(name) };
    return get_object_type( &str );
}

262
static int desktop_close_handle( struct object *obj, struct process *process, obj_handle_t handle )
263
{
264
    struct thread *thread;
265

266 267 268 269 270
    /* check if the handle is currently used by the process or one of its threads */
    if (process->desktop == handle) return 0;
    LIST_FOR_EACH_ENTRY( thread, &process->thread_list, struct thread, proc_entry )
        if (thread->desktop == handle) return 0;
    return 1;
271 272
}

273
static void desktop_destroy( struct object *obj )
274
{
275
    struct desktop *desktop = (struct desktop *)obj;
276

277
    free_hotkeys( desktop, 0 );
278
    if (desktop->top_window) destroy_window( desktop->top_window );
279
    if (desktop->msg_window) destroy_window( desktop->msg_window );
280
    if (desktop->global_hooks) release_object( desktop->global_hooks );
281
    if (desktop->close_timeout) remove_timeout_user( desktop->close_timeout );
282 283
    list_remove( &desktop->entry );
    release_object( desktop->winstation );
284 285
}

286 287 288 289 290 291 292 293 294 295 296
static unsigned int desktop_map_access( struct object *obj, unsigned int access )
{
    if (access & GENERIC_READ)    access |= STANDARD_RIGHTS_READ | DESKTOP_READOBJECTS | DESKTOP_ENUMERATE;
    if (access & GENERIC_WRITE)   access |= STANDARD_RIGHTS_WRITE | DESKTOP_CREATEMENU | DESKTOP_CREATEWINDOW |
                                            DESKTOP_HOOKCONTROL | DESKTOP_JOURNALRECORD | DESKTOP_JOURNALPLAYBACK |
                                            DESKTOP_WRITEOBJECTS;
    if (access & GENERIC_EXECUTE) access |= STANDARD_RIGHTS_EXECUTE | DESKTOP_SWITCHDESKTOP;
    if (access & GENERIC_ALL)     access |= STANDARD_RIGHTS_REQUIRED | DESKTOP_ALL_ACCESS;
    return access & ~(GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | GENERIC_ALL);
}

297 298 299 300 301 302
/* retrieve the thread desktop, checking the handle access rights */
struct desktop *get_thread_desktop( struct thread *thread, unsigned int access )
{
    return get_desktop_obj( thread->process, thread->desktop, access );
}

303 304 305
/* set the process default desktop handle */
void set_process_default_desktop( struct process *process, struct desktop *desktop,
                                  obj_handle_t handle )
306
{
307 308
    struct thread *thread;
    struct desktop *old_desktop;
309

310
    if (process->desktop == handle) return;  /* nothing to do */
311

312 313
    if (!(old_desktop = get_desktop_obj( process, process->desktop, 0 ))) clear_error();
    process->desktop = handle;
314

315 316 317 318
    /* set desktop for threads that don't have one yet */
    LIST_FOR_EACH_ENTRY( thread, &process->thread_list, struct thread, proc_entry )
        if (!thread->desktop) thread->desktop = handle;

319
    if (!process->is_system)
320
    {
321 322 323 324 325 326 327
        desktop->users++;
        if (desktop->close_timeout)
        {
            remove_timeout_user( desktop->close_timeout );
            desktop->close_timeout = NULL;
        }
        if (old_desktop) old_desktop->users--;
328
    }
329 330

    if (old_desktop) release_object( old_desktop );
331 332
}

333 334
/* connect a process to its window station */
void connect_process_winstation( struct process *process, struct thread *parent )
335
{
336 337 338
    struct winstation *winstation = NULL;
    struct desktop *desktop = NULL;
    obj_handle_t handle;
339

340 341 342 343 344 345
    /* check for an inherited winstation handle (don't ask...) */
    if ((handle = find_inherited_handle( process, &winstation_ops )))
    {
        winstation = (struct winstation *)get_handle_obj( process, handle, 0, &winstation_ops );
    }
    else if (parent && parent->process->winstation)
346
    {
347 348 349 350 351 352
        handle = duplicate_handle( parent->process, parent->process->winstation,
                                   process, 0, 0, DUP_HANDLE_SAME_ACCESS );
        winstation = (struct winstation *)get_handle_obj( process, handle, 0, &winstation_ops );
    }
    if (!winstation) goto done;
    process->winstation = handle;
353

354 355 356 357
    if ((handle = find_inherited_handle( process, &desktop_ops )))
    {
        desktop = get_desktop_obj( process, handle, 0 );
        if (!desktop || desktop->winstation != winstation) goto done;
358
    }
359 360 361 362 363 364 365 366 367 368 369 370 371 372
    else if (parent && parent->desktop)
    {
        desktop = get_desktop_obj( parent->process, parent->desktop, 0 );
        if (!desktop || desktop->winstation != winstation) goto done;
        handle = duplicate_handle( parent->process, parent->desktop,
                                   process, 0, 0, DUP_HANDLE_SAME_ACCESS );
    }

    if (handle) set_process_default_desktop( process, desktop, handle );

done:
    if (desktop) release_object( desktop );
    if (winstation) release_object( winstation );
    clear_error();
373 374
}

375 376 377 378 379 380
static void close_desktop_timeout( void *private )
{
    struct desktop *desktop = private;

    desktop->close_timeout = NULL;
    unlink_named_object( &desktop->obj );  /* make sure no other process can open it */
381
    post_desktop_message( desktop, WM_CLOSE, 0, 0 );  /* and signal the owner to quit */
382 383 384 385 386 387 388 389 390 391 392 393 394 395
}

/* close the desktop of a given process */
void close_process_desktop( struct process *process )
{
    struct desktop *desktop;

    if (process->desktop && (desktop = get_desktop_obj( process, process->desktop, 0 )))
    {
        assert( desktop->users > 0 );
        desktop->users--;
        /* if we have one remaining user, it has to be the manager of the desktop window */
        if (desktop->users == 1 && get_top_window_owner( desktop ))
        {
396
            assert( !desktop->close_timeout );
397
            desktop->close_timeout = add_timeout_user( -TICKS_PER_SEC, close_desktop_timeout, desktop );
398 399 400 401 402 403
        }
        release_object( desktop );
    }
    clear_error();  /* ignore errors */
}

404 405 406 407 408 409
/* close the desktop of a given thread */
void close_thread_desktop( struct thread *thread )
{
    obj_handle_t handle = thread->desktop;

    thread->desktop = 0;
410
    if (handle) close_handle( thread->process, handle );
411 412
}

413 414 415 416 417 418 419 420 421 422 423 424 425 426
/* set the reply data from the object name */
static void set_reply_data_obj_name( struct object *obj )
{
    data_size_t len;
    const WCHAR *ptr, *name = get_object_name( obj, &len );

    /* if there is a backslash return the part of the name after it */
    if (name && (ptr = memchrW( name, '\\', len/sizeof(WCHAR) )))
    {
        len -= (ptr + 1 - name) * sizeof(WCHAR);
        name = ptr + 1;
    }
    if (name) set_reply_data( name, min( len, get_reply_max_size() ));
}
427 428 429 430 431

/* create a window station */
DECL_HANDLER(create_winstation)
{
    struct winstation *winstation;
432
    struct unicode_str name;
433 434

    reply->handle = 0;
435
    get_req_unicode_str( &name );
436
    if ((winstation = create_winstation( &name, req->attributes, req->flags )))
437
    {
438
        reply->handle = alloc_handle( current->process, winstation, req->access, req->attributes );
439 440 441 442 443 444 445
        release_object( winstation );
    }
}

/* open a handle to a window station */
DECL_HANDLER(open_winstation)
{
446 447 448
    struct unicode_str name;

    get_req_unicode_str( &name );
449
    if (winstation_namespace)
450
        reply->handle = open_object( winstation_namespace, &name, &winstation_ops, req->access,
451
                                     req->attributes );
452 453 454 455 456 457 458 459 460 461 462 463 464
    else
        set_error( STATUS_OBJECT_NAME_NOT_FOUND );
}


/* close a window station */
DECL_HANDLER(close_winstation)
{
    struct winstation *winstation;

    if ((winstation = (struct winstation *)get_handle_obj( current->process, req->handle,
                                                           0, &winstation_ops )))
    {
465
        if (close_handle( current->process, req->handle )) set_error( STATUS_ACCESS_DENIED );
466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496
        release_object( winstation );
    }
}


/* get the process current window station */
DECL_HANDLER(get_process_winstation)
{
    reply->handle = current->process->winstation;
}


/* set the process current window station */
DECL_HANDLER(set_process_winstation)
{
    struct winstation *winstation;

    if ((winstation = (struct winstation *)get_handle_obj( current->process, req->handle,
                                                           0, &winstation_ops )))
    {
        /* FIXME: should we close the old one? */
        current->process->winstation = req->handle;
        release_object( winstation );
    }
}

/* create a desktop */
DECL_HANDLER(create_desktop)
{
    struct desktop *desktop;
    struct winstation *winstation;
497
    struct unicode_str name;
498 499

    reply->handle = 0;
500
    get_req_unicode_str( &name );
501 502
    if ((winstation = get_process_winstation( current->process, WINSTA_CREATEDESKTOP )))
    {
503
        if ((desktop = create_desktop( &name, req->attributes, req->flags, winstation )))
504
        {
505
            reply->handle = alloc_handle( current->process, desktop, req->access, req->attributes );
506 507 508 509 510 511 512 513 514 515
            release_object( desktop );
        }
        release_object( winstation );
    }
}

/* open a handle to a desktop */
DECL_HANDLER(open_desktop)
{
    struct winstation *winstation;
516
    struct unicode_str name;
517

518
    get_req_unicode_str( &name );
519 520 521 522 523 524 525 526

    /* FIXME: check access rights */
    if (!req->winsta)
        winstation = get_process_winstation( current->process, 0 );
    else
        winstation = (struct winstation *)get_handle_obj( current->process, req->winsta, 0, &winstation_ops );

    if (winstation)
527
    {
528
        struct unicode_str full_str;
529 530
        WCHAR *full_name;

531
        if ((full_name = build_desktop_name( &name, winstation, &full_str )))
532
        {
533
            reply->handle = open_object( winstation_namespace, &full_str, &desktop_ops, req->access,
534
                                         req->attributes );
535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550
            free( full_name );
        }
        release_object( winstation );
    }
}


/* close a desktop */
DECL_HANDLER(close_desktop)
{
    struct desktop *desktop;

    /* make sure it is a desktop handle */
    if ((desktop = (struct desktop *)get_handle_obj( current->process, req->handle,
                                                     0, &desktop_ops )))
    {
551
        if (close_handle( current->process, req->handle )) set_error( STATUS_DEVICE_BUSY );
552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570
        release_object( desktop );
    }
}


/* get the thread current desktop */
DECL_HANDLER(get_thread_desktop)
{
    struct thread *thread;

    if (!(thread = get_thread_from_id( req->tid ))) return;
    reply->handle = thread->desktop;
    release_object( thread );
}


/* set the thread current desktop */
DECL_HANDLER(set_thread_desktop)
{
571 572
    struct desktop *old_desktop, *new_desktop;
    struct winstation *winstation;
573

574 575 576 577
    if (!(winstation = get_process_winstation( current->process, 0 /* FIXME: access rights? */ )))
        return;

    if (!(new_desktop = get_desktop_obj( current->process, req->handle, 0 )))
578
    {
579 580
        release_object( winstation );
        return;
581
    }
582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600
    if (new_desktop->winstation != winstation)
    {
        set_error( STATUS_ACCESS_DENIED );
        release_object( new_desktop );
        release_object( winstation );
        return;
    }

    /* check if we are changing to a new desktop */

    if (!(old_desktop = get_desktop_obj( current->process, current->desktop, 0)))
        clear_error();  /* ignore error */

    /* when changing desktop, we can't have any users on the current one */
    if (old_desktop != new_desktop && current->desktop_users > 0)
        set_error( STATUS_DEVICE_BUSY );
    else
        current->desktop = req->handle;  /* FIXME: should we close the old one? */

601 602 603
    if (!current->process->desktop)
        set_process_default_desktop( current->process, new_desktop, req->handle );

604
    if (old_desktop != new_desktop && current->queue) detach_thread_input( current );
605

606 607 608
    if (old_desktop) release_object( old_desktop );
    release_object( new_desktop );
    release_object( winstation );
609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638
}


/* get/set information about a user object (window station or desktop) */
DECL_HANDLER(set_user_object_info)
{
    struct object *obj;

    if (!(obj = get_handle_obj( current->process, req->handle, 0, NULL ))) return;

    if (obj->ops == &desktop_ops)
    {
        struct desktop *desktop = (struct desktop *)obj;
        reply->is_desktop = 1;
        reply->old_obj_flags = desktop->flags;
        if (req->flags & SET_USER_OBJECT_FLAGS) desktop->flags = req->obj_flags;
    }
    else if (obj->ops == &winstation_ops)
    {
        struct winstation *winstation = (struct winstation *)obj;
        reply->is_desktop = 0;
        reply->old_obj_flags = winstation->flags;
        if (req->flags & SET_USER_OBJECT_FLAGS) winstation->flags = req->obj_flags;
    }
    else
    {
        set_error( STATUS_OBJECT_TYPE_MISMATCH );
        release_object( obj );
        return;
    }
639 640 641 642 643 644 645 646
    if (get_reply_max_size()) set_reply_data_obj_name( obj );
    release_object( obj );
}


/* enumerate window stations */
DECL_HANDLER(enum_winstation)
{
647 648
    unsigned int index = 0;
    struct winstation *winsta;
649

650
    LIST_FOR_EACH_ENTRY( winsta, &winstation_list, struct winstation, entry )
651
    {
652 653 654 655
        unsigned int access = WINSTA_ENUMERATE;
        if (req->index > index++) continue;
        if (!check_object_access( &winsta->obj, &access )) continue;
        set_reply_data_obj_name( &winsta->obj );
656 657 658 659 660 661 662 663 664 665 666 667 668
        clear_error();
        reply->next = index;
        return;
    }
    set_error( STATUS_NO_MORE_ENTRIES );
}


/* enumerate desktops */
DECL_HANDLER(enum_desktop)
{
    struct winstation *winstation;
    struct desktop *desktop;
669
    unsigned int index = 0;
670 671 672 673 674

    if (!(winstation = (struct winstation *)get_handle_obj( current->process, req->winstation,
                                                            WINSTA_ENUMDESKTOPS, &winstation_ops )))
        return;

675
    LIST_FOR_EACH_ENTRY( desktop, &winstation->desktops, struct desktop, entry )
676
    {
677 678 679 680 681 682 683 684 685
        unsigned int access = DESKTOP_ENUMERATE;
        if (req->index > index++) continue;
        if (!desktop->obj.name) continue;
        if (!check_object_access( &desktop->obj, &access )) continue;
        set_reply_data_obj_name( &desktop->obj );
        release_object( winstation );
        clear_error();
        reply->next = index;
        return;
686
    }
687 688 689

    release_object( winstation );
    set_error( STATUS_NO_MORE_ENTRIES );
690
}