dlls/user32/winstation.c

   1 /*
   2  * Window stations and desktops
   3  *
   4  * Copyright 2002 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * 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 #include "ntstatus.h"
  22 #define WIN32_NO_STATUS
  23
  24 #include <stdarg.h>
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winnls.h"
  28 #include "winerror.h"
  29 #include "wingdi.h"
  30 #include "winuser.h"
  31 #include "winternl.h"
  32 #include "ddk/wdm.h"
  33 #include "wine/server.h"
  34 #include "wine/unicode.h"
  35 #include "wine/debug.h"
  36 #include "user_private.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(winstation);
  39
  40
  41 /* callback for enumeration functions */
  42 struct enum_proc_lparam
  43 {
  44     NAMEENUMPROCA func;
  45     LPARAM        lparam;
  46 };
  47
  48 static BOOL CALLBACK enum_names_WtoA( LPWSTR name, LPARAM lparam )
  49 {
  50     struct enum_proc_lparam *data = (struct enum_proc_lparam *)lparam;
  51     char buffer[MAX_PATH];
  52
  53     if (!WideCharToMultiByte( CP_ACP, 0, name, -1, buffer, sizeof(buffer), NULL, NULL ))
  54         return FALSE;
  55     return data->func( buffer, data->lparam );
  56 }
  57
  58 /* return a handle to the directory where window station objects are created */
  59 static HANDLE get_winstations_dir_handle(void)
  60 {
  61     static HANDLE handle = NULL;
  62     static const WCHAR basenameW[] = {'\\','W','i','n','d','o','w','s','\\',
  63                                       'W','i','n','d','o','w','S','t','a','t','i','o','n','s',0};
  64     UNICODE_STRING str;
  65     OBJECT_ATTRIBUTES attr;
  66
  67     if (!handle)
  68     {
  69         HANDLE dir;
  70
  71         RtlInitUnicodeString( &str, basenameW );
  72         InitializeObjectAttributes( &attr, &str, 0, 0, NULL );
  73         NtOpenDirectoryObject( &dir, DIRECTORY_CREATE_OBJECT | DIRECTORY_TRAVERSE, &attr );
  74         if (InterlockedCompareExchangePointer( &handle, dir, 0 ) != 0) /* someone beat us here */
  75             CloseHandle( dir );
  76     }
  77     return handle;
  78 }
  79
  80 /***********************************************************************
  81  *              CreateWindowStationA  (USER32.@)
  82  */
  83 HWINSTA WINAPI CreateWindowStationA( LPCSTR name, DWORD reserved, ACCESS_MASK access,
  84                                      LPSECURITY_ATTRIBUTES sa )
  85 {
  86     WCHAR buffer[MAX_PATH];
  87
  88     if (!name) return CreateWindowStationW( NULL, reserved, access, sa );
  89
  90     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
  91     {
  92         SetLastError( ERROR_FILENAME_EXCED_RANGE );
  93         return 0;
  94     }
  95     return CreateWindowStationW( buffer, reserved, access, sa );
  96 }
  97
  98
  99 /***********************************************************************
 100  *              CreateWindowStationW  (USER32.@)
 101  */
 102 HWINSTA WINAPI CreateWindowStationW( LPCWSTR name, DWORD reserved, ACCESS_MASK access,
 103                                      LPSECURITY_ATTRIBUTES sa )
 104 {
 105     HANDLE ret;
 106     DWORD len = name ? strlenW(name) : 0;
 107
 108     if (len >= MAX_PATH)
 109     {
 110         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 111         return 0;
 112     }
 113     SERVER_START_REQ( create_winstation )
 114     {
 115         req->flags      = 0;
 116         req->access     = access;
 117         req->attributes = OBJ_CASE_INSENSITIVE | OBJ_OPENIF |
 118                           ((sa && sa->bInheritHandle) ? OBJ_INHERIT : 0);
 119         req->rootdir    = wine_server_obj_handle( get_winstations_dir_handle() );
 120         wine_server_add_data( req, name, len * sizeof(WCHAR) );
 121         wine_server_call_err( req );
 122         ret = wine_server_ptr_handle( reply->handle );
 123     }
 124     SERVER_END_REQ;
 125     return ret;
 126 }
 127
 128
 129 /******************************************************************************
 130  *              OpenWindowStationA  (USER32.@)
 131  */
 132 HWINSTA WINAPI OpenWindowStationA( LPCSTR name, BOOL inherit, ACCESS_MASK access )
 133 {
 134     WCHAR buffer[MAX_PATH];
 135
 136     if (!name) return OpenWindowStationW( NULL, inherit, access );
 137
 138     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 139     {
 140         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 141         return 0;
 142     }
 143     return OpenWindowStationW( buffer, inherit, access );
 144 }
 145
 146
 147 /******************************************************************************
 148  *              OpenWindowStationW  (USER32.@)
 149  */
 150 HWINSTA WINAPI OpenWindowStationW( LPCWSTR name, BOOL inherit, ACCESS_MASK access )
 151 {
 152     HANDLE ret = 0;
 153     DWORD len = name ? strlenW(name) : 0;
 154     if (len >= MAX_PATH)
 155     {
 156         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 157         return 0;
 158     }
 159     SERVER_START_REQ( open_winstation )
 160     {
 161         req->access     = access;
 162         req->attributes = OBJ_CASE_INSENSITIVE | (inherit ? OBJ_INHERIT : 0);
 163         req->rootdir    = wine_server_obj_handle( get_winstations_dir_handle() );
 164         wine_server_add_data( req, name, len * sizeof(WCHAR) );
 165         if (!wine_server_call_err( req )) ret = wine_server_ptr_handle( reply->handle );
 166     }
 167     SERVER_END_REQ;
 168     return ret;
 169 }
 170
 171
 172 /***********************************************************************
 173  *              CloseWindowStation  (USER32.@)
 174  */
 175 BOOL WINAPI CloseWindowStation( HWINSTA handle )
 176 {
 177     BOOL ret;
 178     SERVER_START_REQ( close_winstation )
 179     {
 180         req->handle = wine_server_obj_handle( handle );
 181         ret = !wine_server_call_err( req );
 182     }
 183     SERVER_END_REQ;
 184     return ret;
 185 }
 186
 187
 188 /******************************************************************************
 189  *              GetProcessWindowStation  (USER32.@)
 190  */
 191 HWINSTA WINAPI GetProcessWindowStation(void)
 192 {
 193     HWINSTA ret = 0;
 194
 195     SERVER_START_REQ( get_process_winstation )
 196     {
 197         if (!wine_server_call_err( req ))
 198             ret = wine_server_ptr_handle( reply->handle );
 199     }
 200     SERVER_END_REQ;
 201     return ret;
 202 }
 203
 204
 205 /***********************************************************************
 206  *              SetProcessWindowStation  (USER32.@)
 207  */
 208 BOOL WINAPI SetProcessWindowStation( HWINSTA handle )
 209 {
 210     BOOL ret;
 211
 212     SERVER_START_REQ( set_process_winstation )
 213     {
 214         req->handle = wine_server_obj_handle( handle );
 215         ret = !wine_server_call_err( req );
 216     }
 217     SERVER_END_REQ;
 218     return ret;
 219 }
 220
 221
 222 /******************************************************************************
 223  *              EnumWindowStationsA  (USER32.@)
 224  */
 225 BOOL WINAPI EnumWindowStationsA( WINSTAENUMPROCA func, LPARAM lparam )
 226 {
 227     struct enum_proc_lparam data;
 228     data.func   = func;
 229     data.lparam = lparam;
 230     return EnumWindowStationsW( enum_names_WtoA, (LPARAM)&data );
 231 }
 232
 233
 234 /******************************************************************************
 235  *              EnumWindowStationsW  (USER32.@)
 236  */
 237 BOOL WINAPI EnumWindowStationsW( WINSTAENUMPROCW func, LPARAM lparam )
 238 {
 239     unsigned int index = 0;
 240     WCHAR name[MAX_PATH];
 241     BOOL ret = TRUE;
 242     NTSTATUS status;
 243
 244     while (ret)
 245     {
 246         SERVER_START_REQ( enum_winstation )
 247         {
 248             req->index = index;
 249             wine_server_set_reply( req, name, sizeof(name) - sizeof(WCHAR) );
 250             status = wine_server_call( req );
 251             name[wine_server_reply_size(reply)/sizeof(WCHAR)] = 0;
 252             index = reply->next;
 253         }
 254         SERVER_END_REQ;
 255         if (status == STATUS_NO_MORE_ENTRIES)
 256             break;
 257         if (status)
 258         {
 259             SetLastError( RtlNtStatusToDosError( status ) );
 260             return FALSE;
 261         }
 262         ret = func( name, lparam );
 263     }
 264     return ret;
 265 }
 266
 267
 268 /***********************************************************************
 269  *              CreateDesktopA   (USER32.@)
 270  */
 271 HDESK WINAPI CreateDesktopA( LPCSTR name, LPCSTR device, LPDEVMODEA devmode,
 272                              DWORD flags, ACCESS_MASK access, LPSECURITY_ATTRIBUTES sa )
 273 {
 274     WCHAR buffer[MAX_PATH];
 275
 276     if (device || devmode)
 277     {
 278         SetLastError( ERROR_INVALID_PARAMETER );
 279         return 0;
 280     }
 281     if (!name) return CreateDesktopW( NULL, NULL, NULL, flags, access, sa );
 282
 283     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 284     {
 285         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 286         return 0;
 287     }
 288     return CreateDesktopW( buffer, NULL, NULL, flags, access, sa );
 289 }
 290
 291
 292 /***********************************************************************
 293  *              CreateDesktopW   (USER32.@)
 294  */
 295 HDESK WINAPI CreateDesktopW( LPCWSTR name, LPCWSTR device, LPDEVMODEW devmode,
 296                              DWORD flags, ACCESS_MASK access, LPSECURITY_ATTRIBUTES sa )
 297 {
 298     HANDLE ret;
 299     DWORD len = name ? strlenW(name) : 0;
 300
 301     if (device || devmode)
 302     {
 303         SetLastError( ERROR_INVALID_PARAMETER );
 304         return 0;
 305     }
 306     if (len >= MAX_PATH)
 307     {
 308         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 309         return 0;
 310     }
 311     SERVER_START_REQ( create_desktop )
 312     {
 313         req->flags      = flags;
 314         req->access     = access;
 315         req->attributes = OBJ_CASE_INSENSITIVE | OBJ_OPENIF |
 316                           ((sa && sa->bInheritHandle) ? OBJ_INHERIT : 0);
 317         wine_server_add_data( req, name, len * sizeof(WCHAR) );
 318         wine_server_call_err( req );
 319         ret = wine_server_ptr_handle( reply->handle );
 320     }
 321     SERVER_END_REQ;
 322     return ret;
 323 }
 324
 325
 326 /******************************************************************************
 327  *              OpenDesktopA   (USER32.@)
 328  */
 329 HDESK WINAPI OpenDesktopA( LPCSTR name, DWORD flags, BOOL inherit, ACCESS_MASK access )
 330 {
 331     WCHAR buffer[MAX_PATH];
 332
 333     if (!name) return OpenDesktopW( NULL, flags, inherit, access );
 334
 335     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 336     {
 337         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 338         return 0;
 339     }
 340     return OpenDesktopW( buffer, flags, inherit, access );
 341 }
 342
 343
 344 HDESK open_winstation_desktop( HWINSTA hwinsta, LPCWSTR name, DWORD flags, BOOL inherit, ACCESS_MASK access )
 345 {
 346     HANDLE ret = 0;
 347     DWORD len = name ? strlenW(name) : 0;
 348     if (len >= MAX_PATH)
 349     {
 350         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 351         return 0;
 352     }
 353     SERVER_START_REQ( open_desktop )
 354     {
 355         req->winsta     = wine_server_obj_handle( hwinsta );
 356         req->flags      = flags;
 357         req->access     = access;
 358         req->attributes = OBJ_CASE_INSENSITIVE | (inherit ? OBJ_INHERIT : 0);
 359         wine_server_add_data( req, name, len * sizeof(WCHAR) );
 360         if (!wine_server_call_err( req )) ret = wine_server_ptr_handle( reply->handle );
 361     }
 362     SERVER_END_REQ;
 363     return ret;
 364 }
 365
 366
 367 /******************************************************************************
 368  *              OpenDesktopW   (USER32.@)
 369  */
 370 HDESK WINAPI OpenDesktopW( LPCWSTR name, DWORD flags, BOOL inherit, ACCESS_MASK access )
 371 {
 372     return open_winstation_desktop( NULL, name, flags, inherit, access );
 373 }
 374
 375
 376 /***********************************************************************
 377  *              CloseDesktop  (USER32.@)
 378  */
 379 BOOL WINAPI CloseDesktop( HDESK handle )
 380 {
 381     BOOL ret;
 382     SERVER_START_REQ( close_desktop )
 383     {
 384         req->handle = wine_server_obj_handle( handle );
 385         ret = !wine_server_call_err( req );
 386     }
 387     SERVER_END_REQ;
 388     return ret;
 389 }
 390
 391
 392 /******************************************************************************
 393  *              GetThreadDesktop   (USER32.@)
 394  */
 395 HDESK WINAPI GetThreadDesktop( DWORD thread )
 396 {
 397     HDESK ret = 0;
 398
 399     SERVER_START_REQ( get_thread_desktop )
 400     {
 401         req->tid = thread;
 402         if (!wine_server_call_err( req )) ret = wine_server_ptr_handle( reply->handle );
 403     }
 404     SERVER_END_REQ;
 405     return ret;
 406 }
 407
 408
 409 /******************************************************************************
 410  *              SetThreadDesktop   (USER32.@)
 411  */
 412 BOOL WINAPI SetThreadDesktop( HDESK handle )
 413 {
 414     BOOL ret;
 415
 416     SERVER_START_REQ( set_thread_desktop )
 417     {
 418         req->handle = wine_server_obj_handle( handle );
 419         ret = !wine_server_call_err( req );
 420     }
 421     SERVER_END_REQ;
 422     if (ret)  /* reset the desktop windows */
 423     {
 424         struct user_thread_info *thread_info = get_user_thread_info();
 425         struct user_key_state_info *key_state_info = thread_info->key_state;
 426         thread_info->top_window = 0;
 427         thread_info->msg_window = 0;
 428         if (key_state_info) key_state_info->time = 0;
 429     }
 430     return ret;
 431 }
 432
 433
 434 /******************************************************************************
 435  *              EnumDesktopsA   (USER32.@)
 436  */
 437 BOOL WINAPI EnumDesktopsA( HWINSTA winsta, DESKTOPENUMPROCA func, LPARAM lparam )
 438 {
 439     struct enum_proc_lparam data;
 440     data.func   = func;
 441     data.lparam = lparam;
 442     return EnumDesktopsW( winsta, enum_names_WtoA, (LPARAM)&data );
 443 }
 444
 445
 446 /******************************************************************************
 447  *              EnumDesktopsW   (USER32.@)
 448  */
 449 BOOL WINAPI EnumDesktopsW( HWINSTA winsta, DESKTOPENUMPROCW func, LPARAM lparam )
 450 {
 451     unsigned int index = 0;
 452     WCHAR name[MAX_PATH];
 453     BOOL ret = TRUE;
 454     NTSTATUS status;
 455
 456     if (!winsta)
 457         winsta = GetProcessWindowStation();
 458
 459     while (ret)
 460     {
 461         SERVER_START_REQ( enum_desktop )
 462         {
 463             req->winstation = wine_server_obj_handle( winsta );
 464             req->index      = index;
 465             wine_server_set_reply( req, name, sizeof(name) - sizeof(WCHAR) );
 466             status = wine_server_call( req );
 467             name[wine_server_reply_size(reply)/sizeof(WCHAR)] = 0;
 468             index = reply->next;
 469         }
 470         SERVER_END_REQ;
 471         if (status == STATUS_NO_MORE_ENTRIES)
 472             break;
 473         if (status)
 474         {
 475             SetLastError( RtlNtStatusToDosError( status ) );
 476             return FALSE;
 477         }
 478         ret = func(name, lparam);
 479     }
 480     return ret;
 481 }
 482
 483
 484 /******************************************************************************
 485  *              OpenInputDesktop   (USER32.@)
 486  */
 487 HDESK WINAPI OpenInputDesktop( DWORD flags, BOOL inherit, ACCESS_MASK access )
 488 {
 489     HANDLE ret = 0;
 490
 491     TRACE( "(%x,%i,%x)\n", flags, inherit, access );
 492
 493     if (flags)
 494         FIXME( "partial stub flags %08x\n", flags );
 495
 496     SERVER_START_REQ( open_input_desktop )
 497     {
 498         req->flags      = flags;
 499         req->access     = access;
 500         req->attributes = inherit ? OBJ_INHERIT : 0;
 501         if (!wine_server_call_err( req )) ret = wine_server_ptr_handle( reply->handle );
 502     }
 503     SERVER_END_REQ;
 504
 505     return ret;
 506 }
 507
 508
 509 /***********************************************************************
 510  *              GetUserObjectInformationA   (USER32.@)
 511  */
 512 BOOL WINAPI GetUserObjectInformationA( HANDLE handle, INT index, LPVOID info, DWORD len, LPDWORD needed )
 513 {
 514     /* check for information types returning strings */
 515     if (index == UOI_TYPE || index == UOI_NAME)
 516     {
 517         WCHAR buffer[MAX_PATH];
 518         DWORD lenA, lenW;
 519
 520         if (!GetUserObjectInformationW( handle, index, buffer, sizeof(buffer), &lenW )) return FALSE;
 521         lenA = WideCharToMultiByte( CP_ACP, 0, buffer, -1, NULL, 0, NULL, NULL );
 522         if (needed) *needed = lenA;
 523         if (lenA > len)
 524         {
 525             /* If the buffer length supplied by the caller is insufficient, Windows returns a
 526                'needed' length based upon the Unicode byte length, so we should do similarly. */
 527             if (needed) *needed = lenW;
 528
 529             SetLastError( ERROR_INSUFFICIENT_BUFFER );
 530             return FALSE;
 531         }
 532         if (info) WideCharToMultiByte( CP_ACP, 0, buffer, -1, info, len, NULL, NULL );
 533         return TRUE;
 534     }
 535     return GetUserObjectInformationW( handle, index, info, len, needed );
 536 }
 537
 538
 539 /***********************************************************************
 540  *              GetUserObjectInformationW   (USER32.@)
 541  */
 542 BOOL WINAPI GetUserObjectInformationW( HANDLE handle, INT index, LPVOID info, DWORD len, LPDWORD needed )
 543 {
 544     static const WCHAR desktopW[] = { 'D','e','s','k','t','o','p',0 };
 545     static const WCHAR winstationW[] = { 'W','i','n','d','o','w','S','t','a','t','i','o','n',0 };
 546     BOOL ret;
 547
 548     switch(index)
 549     {
 550     case UOI_FLAGS:
 551         {
 552             USEROBJECTFLAGS *obj_flags = info;
 553             if (needed) *needed = sizeof(*obj_flags);
 554             if (len < sizeof(*obj_flags))
 555             {
 556                 SetLastError( ERROR_BUFFER_OVERFLOW );
 557                 return FALSE;
 558             }
 559             SERVER_START_REQ( set_user_object_info )
 560             {
 561                 req->handle    = wine_server_obj_handle( handle );
 562                 req->flags     = 0;
 563                 ret = !wine_server_call_err( req );
 564                 if (ret)
 565                 {
 566                     /* FIXME: inherit flag */
 567                     obj_flags->dwFlags = reply->old_obj_flags;
 568                 }
 569             }
 570             SERVER_END_REQ;
 571         }
 572         return ret;
 573
 574     case UOI_TYPE:
 575         SERVER_START_REQ( set_user_object_info )
 576         {
 577             req->handle = wine_server_obj_handle( handle );
 578             req->flags  = 0;
 579             ret = !wine_server_call_err( req );
 580             if (ret)
 581             {
 582                 size_t size = reply->is_desktop ? sizeof(desktopW) : sizeof(winstationW);
 583                 if (needed) *needed = size;
 584                 if (len < size)
 585                 {
 586                     SetLastError( ERROR_INSUFFICIENT_BUFFER );
 587                     ret = FALSE;
 588                 }
 589                 else memcpy( info, reply->is_desktop ? desktopW : winstationW, size );
 590             }
 591         }
 592         SERVER_END_REQ;
 593         return ret;
 594
 595     case UOI_NAME:
 596         {
 597             WCHAR buffer[MAX_PATH];
 598             SERVER_START_REQ( set_user_object_info )
 599             {
 600                 req->handle = wine_server_obj_handle( handle );
 601                 req->flags  = 0;
 602                 wine_server_set_reply( req, buffer, sizeof(buffer) - sizeof(WCHAR) );
 603                 ret = !wine_server_call_err( req );
 604                 if (ret)
 605                 {
 606                     size_t size = wine_server_reply_size( reply );
 607                     buffer[size / sizeof(WCHAR)] = 0;
 608                     size += sizeof(WCHAR);
 609                     if (needed) *needed = size;
 610                     if (len < size)
 611                     {
 612                         SetLastError( ERROR_INSUFFICIENT_BUFFER );
 613                         ret = FALSE;
 614                     }
 615                     else memcpy( info, buffer, size );
 616                 }
 617             }
 618             SERVER_END_REQ;
 619         }
 620         return ret;
 621
 622     case UOI_USER_SID:
 623         FIXME( "not supported index %d\n", index );
 624         /* fall through */
 625     default:
 626         SetLastError( ERROR_INVALID_PARAMETER );
 627         return FALSE;
 628     }
 629 }
 630
 631
 632 /******************************************************************************
 633  *              SetUserObjectInformationA   (USER32.@)
 634  */
 635 BOOL WINAPI SetUserObjectInformationA( HANDLE handle, INT index, LPVOID info, DWORD len )
 636 {
 637     return SetUserObjectInformationW( handle, index, info, len );
 638 }
 639
 640
 641 /******************************************************************************
 642  *              SetUserObjectInformationW   (USER32.@)
 643  */
 644 BOOL WINAPI SetUserObjectInformationW( HANDLE handle, INT index, LPVOID info, DWORD len )
 645 {
 646     BOOL ret;
 647     const USEROBJECTFLAGS *obj_flags = info;
 648
 649     if (index != UOI_FLAGS || !info || len < sizeof(*obj_flags))
 650     {
 651         SetLastError( ERROR_INVALID_PARAMETER );
 652         return FALSE;
 653     }
 654     /* FIXME: inherit flag */
 655     SERVER_START_REQ( set_user_object_info )
 656     {
 657         req->handle    = wine_server_obj_handle( handle );
 658         req->flags     = SET_USER_OBJECT_SET_FLAGS;
 659         req->obj_flags = obj_flags->dwFlags;
 660         ret = !wine_server_call_err( req );
 661     }
 662     SERVER_END_REQ;
 663     return ret;
 664 }
 665
 666
 667 /***********************************************************************
 668  *              GetUserObjectSecurity   (USER32.@)
 669  */
 670 BOOL WINAPI GetUserObjectSecurity( HANDLE handle, PSECURITY_INFORMATION info,
 671                                    PSECURITY_DESCRIPTOR sid, DWORD len, LPDWORD needed )
 672 {
 673     FIXME( "(%p %p %p len=%d %p),stub!\n", handle, info, sid, len, needed );
 674     if (needed)
 675         *needed = sizeof(SECURITY_DESCRIPTOR);
 676     if (len < sizeof(SECURITY_DESCRIPTOR))
 677     {
 678         SetLastError( ERROR_INSUFFICIENT_BUFFER );
 679         return FALSE;
 680     }
 681     return InitializeSecurityDescriptor(sid, SECURITY_DESCRIPTOR_REVISION);
 682 }
 683
 684 /***********************************************************************
 685  *              SetUserObjectSecurity   (USER32.@)
 686  */
 687 BOOL WINAPI SetUserObjectSecurity( HANDLE handle, PSECURITY_INFORMATION info,
 688                                    PSECURITY_DESCRIPTOR sid )
 689 {
 690     FIXME( "(%p,%p,%p),stub!\n", handle, info, sid );
 691     return TRUE;
 692 }