winstation.c 23.1 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 233
            desktop->close_timeout = NULL;
            desktop->users = 0;
234 235 236 237 238 239 240 241 242 243 244
            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;

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

251 252 253 254 255 256 257
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 );
}

258
static int desktop_close_handle( struct object *obj, struct process *process, obj_handle_t handle )
259
{
260
    struct thread *thread;
261

262 263 264 265 266
    /* 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;
267 268
}

269
static void desktop_destroy( struct object *obj )
270
{
271
    struct desktop *desktop = (struct desktop *)obj;
272

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

281 282 283 284 285 286 287 288 289 290 291
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);
}

292 293 294 295 296 297
/* 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 );
}

298 299 300
/* set the process default desktop handle */
void set_process_default_desktop( struct process *process, struct desktop *desktop,
                                  obj_handle_t handle )
301
{
302 303
    struct thread *thread;
    struct desktop *old_desktop;
304

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

307 308
    if (!(old_desktop = get_desktop_obj( process, process->desktop, 0 ))) clear_error();
    process->desktop = handle;
309

310 311 312 313
    /* 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;

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

    if (old_desktop) release_object( old_desktop );
326 327
}

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

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

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

370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390
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 */
    close_desktop_window( desktop );  /* and signal the owner to quit */
}

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

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

    thread->desktop = 0;
405
    if (handle) close_handle( thread->process, handle );
406
    clear_error();  /* ignore errors */
407 408
}

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

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

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

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

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

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

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

514
    get_req_unicode_str( &name );
515 516 517 518 519 520 521 522

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

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

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

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

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

600
    if (old_desktop != new_desktop && current->queue) detach_thread_input( current );
601

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


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


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

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


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

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

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

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