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 238 239 240 241 242 243 244 245 246 247
            list_add_tail( &winstation->desktops, &desktop->entry );
        }
    }
    free( full_name );
    return desktop;
}

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

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

254 255 256 257 258 259 260
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 );
}

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

265 266 267 268 269
    /* 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;
270 271
}

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

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

284 285 286 287 288 289 290 291 292 293 294
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);
}

295 296 297 298 299 300
/* 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 );
}

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

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

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

313 314 315 316
    /* 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;

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

    if (old_desktop) release_object( old_desktop );
329 330
}

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

338 339 340 341 342 343
    /* 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)
344
    {
345 346 347 348 349 350
        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;
351

352 353 354 355
    if ((handle = find_inherited_handle( process, &desktop_ops )))
    {
        desktop = get_desktop_obj( process, handle, 0 );
        if (!desktop || desktop->winstation != winstation) goto done;
356
    }
357 358 359 360 361 362 363 364 365 366 367 368 369 370
    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();
371 372
}

373 374 375 376 377 378
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 */
379
    post_desktop_message( desktop, WM_CLOSE, 0, 0 );  /* and signal the owner to quit */
380 381 382 383 384 385 386 387 388 389 390 391 392 393
}

/* 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 ))
        {
394
            assert( !desktop->close_timeout );
395
            desktop->close_timeout = add_timeout_user( -TICKS_PER_SEC, close_desktop_timeout, desktop );
396 397 398 399 400 401
        }
        release_object( desktop );
    }
    clear_error();  /* ignore errors */
}

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

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

411 412 413 414 415 416 417 418 419 420 421 422 423 424
/* 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() ));
}
425 426 427 428 429

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

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

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

    get_req_unicode_str( &name );
447
    if (winstation_namespace)
448
        reply->handle = open_object( winstation_namespace, &name, &winstation_ops, req->access,
449
                                     req->attributes );
450 451 452 453 454 455 456 457 458 459 460 461 462
    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 )))
    {
463
        if (close_handle( current->process, req->handle )) set_error( STATUS_ACCESS_DENIED );
464 465 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
        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;
495
    struct unicode_str name;
496 497

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

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

516
    get_req_unicode_str( &name );
517 518 519 520 521 522 523 524

    /* 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)
525
    {
526
        struct unicode_str full_str;
527 528
        WCHAR *full_name;

529
        if ((full_name = build_desktop_name( &name, winstation, &full_str )))
530
        {
531
            reply->handle = open_object( winstation_namespace, &full_str, &desktop_ops, req->access,
532
                                         req->attributes );
533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548
            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 )))
    {
549
        if (close_handle( current->process, req->handle )) set_error( STATUS_DEVICE_BUSY );
550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568
        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)
{
569 570
    struct desktop *old_desktop, *new_desktop;
    struct winstation *winstation;
571

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

    if (!(new_desktop = get_desktop_obj( current->process, req->handle, 0 )))
576
    {
577 578
        release_object( winstation );
        return;
579
    }
580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598
    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? */

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

602
    if (old_desktop != new_desktop && current->queue) detach_thread_input( current );
603

604 605 606
    if (old_desktop) release_object( old_desktop );
    release_object( new_desktop );
    release_object( winstation );
607 608 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
}


/* 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;
    }
637 638 639 640 641 642 643 644
    if (get_reply_max_size()) set_reply_data_obj_name( obj );
    release_object( obj );
}


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

648
    LIST_FOR_EACH_ENTRY( winsta, &winstation_list, struct winstation, entry )
649
    {
650 651 652 653
        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 );
654 655 656 657 658 659 660 661 662 663 664 665 666
        clear_error();
        reply->next = index;
        return;
    }
    set_error( STATUS_NO_MORE_ENTRIES );
}


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

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

673
    LIST_FOR_EACH_ENTRY( desktop, &winstation->desktops, struct desktop, entry )
674
    {
675 676 677 678 679 680 681 682 683
        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;
684
    }
685 686 687

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