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