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     OBJECT_ATTRIBUTES attr;
 129     UNICODE_STRING str;
 130
 131     RtlInitUnicodeString( &str, name );
 132     if (!str.Length) RtlInitUnicodeString( &str, get_winstation_default_name() );
 133
 134     InitializeObjectAttributes( &attr, &str, OBJ_CASE_INSENSITIVE,
 135                                 get_winstations_dir_handle(), sa );
 136     if (!(flags & CWF_CREATE_ONLY)) attr.Attributes |= OBJ_OPENIF;
 137     if (sa && sa->bInheritHandle) attr.Attributes |= OBJ_INHERIT;
 138
 139     return NtUserCreateWindowStation( &attr, access, 0, 0, 0, 0, 0 );
 140 }
 141
 142
 143 /******************************************************************************
 144  *              OpenWindowStationA  (USER32.@)
 145  */
 146 HWINSTA WINAPI OpenWindowStationA( LPCSTR name, BOOL inherit, ACCESS_MASK access )
 147 {
 148     WCHAR buffer[MAX_PATH];
 149
 150     if (!name) return OpenWindowStationW( NULL, inherit, access );
 151
 152     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 153     {
 154         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 155         return 0;
 156     }
 157     return OpenWindowStationW( buffer, inherit, access );
 158 }
 159
 160
 161 /******************************************************************************
 162  *              OpenWindowStationW  (USER32.@)
 163  */
 164 HWINSTA WINAPI OpenWindowStationW( LPCWSTR name, BOOL inherit, ACCESS_MASK access )
 165 {
 166     OBJECT_ATTRIBUTES attr;
 167     UNICODE_STRING str;
 168
 169     RtlInitUnicodeString( &str, name );
 170     if (!str.Length) RtlInitUnicodeString( &str, get_winstation_default_name() );
 171
 172     InitializeObjectAttributes( &attr, &str, OBJ_CASE_INSENSITIVE,
 173                                 get_winstations_dir_handle(), NULL );
 174     if (inherit) attr.Attributes |= OBJ_INHERIT;
 175
 176     return NtUserOpenWindowStation( &attr, access );
 177 }
 178
 179
 180 /******************************************************************************
 181  *              EnumWindowStationsA  (USER32.@)
 182  */
 183 BOOL WINAPI EnumWindowStationsA( WINSTAENUMPROCA func, LPARAM lparam )
 184 {
 185     struct enum_proc_lparam data;
 186     data.func   = func;
 187     data.lparam = lparam;
 188     return EnumWindowStationsW( enum_names_WtoA, (LPARAM)&data );
 189 }
 190
 191
 192 /******************************************************************************
 193  *              EnumWindowStationsW  (USER32.@)
 194  */
 195 BOOL WINAPI EnumWindowStationsW( WINSTAENUMPROCW func, LPARAM lparam )
 196 {
 197     unsigned int index = 0;
 198     WCHAR name[MAX_PATH];
 199     BOOL ret = TRUE;
 200     NTSTATUS status;
 201
 202     while (ret)
 203     {
 204         SERVER_START_REQ( enum_winstation )
 205         {
 206             req->index = index;
 207             wine_server_set_reply( req, name, sizeof(name) - sizeof(WCHAR) );
 208             status = wine_server_call( req );
 209             name[wine_server_reply_size(reply)/sizeof(WCHAR)] = 0;
 210             index = reply->next;
 211         }
 212         SERVER_END_REQ;
 213         if (status == STATUS_NO_MORE_ENTRIES)
 214             break;
 215         if (status)
 216         {
 217             SetLastError( RtlNtStatusToDosError( status ) );
 218             return FALSE;
 219         }
 220         ret = func( name, lparam );
 221     }
 222     return ret;
 223 }
 224
 225
 226 /***********************************************************************
 227  *              CreateDesktopA   (USER32.@)
 228  */
 229 HDESK WINAPI CreateDesktopA( LPCSTR name, LPCSTR device, LPDEVMODEA devmode,
 230                              DWORD flags, ACCESS_MASK access, LPSECURITY_ATTRIBUTES sa )
 231 {
 232     WCHAR buffer[MAX_PATH];
 233
 234     if (device || devmode)
 235     {
 236         SetLastError( ERROR_INVALID_PARAMETER );
 237         return 0;
 238     }
 239     if (!name) return CreateDesktopW( NULL, NULL, NULL, flags, access, sa );
 240
 241     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 242     {
 243         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 244         return 0;
 245     }
 246     return CreateDesktopW( buffer, NULL, NULL, flags, access, sa );
 247 }
 248
 249
 250 /***********************************************************************
 251  *              CreateDesktopW   (USER32.@)
 252  */
 253 HDESK WINAPI CreateDesktopW( LPCWSTR name, LPCWSTR device, LPDEVMODEW devmode,
 254                              DWORD flags, ACCESS_MASK access, LPSECURITY_ATTRIBUTES sa )
 255 {
 256     OBJECT_ATTRIBUTES attr;
 257     UNICODE_STRING str;
 258
 259     if (device || (devmode && !(flags & DF_WINE_VIRTUAL_DESKTOP))
 260         || (flags & DF_WINE_ROOT_DESKTOP && flags & DF_WINE_VIRTUAL_DESKTOP))
 261     {
 262         SetLastError( ERROR_INVALID_PARAMETER );
 263         return 0;
 264     }
 265
 266     RtlInitUnicodeString( &str, name );
 267     InitializeObjectAttributes( &attr, &str, OBJ_CASE_INSENSITIVE | OBJ_OPENIF,
 268                                 get_winstations_dir_handle(), NULL );
 269     if (sa && sa->bInheritHandle) attr.Attributes |= OBJ_INHERIT;
 270     return NtUserCreateDesktopEx( &attr, NULL, devmode, flags, access, 0 );
 271 }
 272
 273
 274 /******************************************************************************
 275  *              OpenDesktopA   (USER32.@)
 276  */
 277 HDESK WINAPI OpenDesktopA( LPCSTR name, DWORD flags, BOOL inherit, ACCESS_MASK access )
 278 {
 279     WCHAR buffer[MAX_PATH];
 280
 281     if (!name) return OpenDesktopW( NULL, flags, inherit, access );
 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 OpenDesktopW( buffer, flags, inherit, access );
 289 }
 290
 291
 292 HDESK open_winstation_desktop( HWINSTA hwinsta, LPCWSTR name, DWORD flags, BOOL inherit, ACCESS_MASK access )
 293 {
 294     OBJECT_ATTRIBUTES attr;
 295     UNICODE_STRING str;
 296
 297     RtlInitUnicodeString( &str, name );
 298     InitializeObjectAttributes( &attr, &str, OBJ_CASE_INSENSITIVE, hwinsta, NULL );
 299     if (inherit) attr.Attributes |= OBJ_INHERIT;
 300     return NtUserOpenDesktop( &attr, flags, access );
 301 }
 302
 303
 304 /******************************************************************************
 305  *              OpenDesktopW   (USER32.@)
 306  */
 307 HDESK WINAPI OpenDesktopW( LPCWSTR name, DWORD flags, BOOL inherit, ACCESS_MASK access )
 308 {
 309     return open_winstation_desktop( NULL, name, flags, inherit, access );
 310 }
 311
 312
 313 /******************************************************************************
 314  *              EnumDesktopsA   (USER32.@)
 315  */
 316 BOOL WINAPI EnumDesktopsA( HWINSTA winsta, DESKTOPENUMPROCA func, LPARAM lparam )
 317 {
 318     struct enum_proc_lparam data;
 319     data.func   = func;
 320     data.lparam = lparam;
 321     return EnumDesktopsW( winsta, enum_names_WtoA, (LPARAM)&data );
 322 }
 323
 324
 325 /******************************************************************************
 326  *              EnumDesktopsW   (USER32.@)
 327  */
 328 BOOL WINAPI EnumDesktopsW( HWINSTA winsta, DESKTOPENUMPROCW func, LPARAM lparam )
 329 {
 330     unsigned int index = 0;
 331     WCHAR name[MAX_PATH];
 332     BOOL ret = TRUE;
 333     NTSTATUS status;
 334
 335     if (!winsta)
 336         winsta = NtUserGetProcessWindowStation();
 337
 338     while (ret)
 339     {
 340         SERVER_START_REQ( enum_desktop )
 341         {
 342             req->winstation = wine_server_obj_handle( winsta );
 343             req->index      = index;
 344             wine_server_set_reply( req, name, sizeof(name) - sizeof(WCHAR) );
 345             status = wine_server_call( req );
 346             name[wine_server_reply_size(reply)/sizeof(WCHAR)] = 0;
 347             index = reply->next;
 348         }
 349         SERVER_END_REQ;
 350         if (status == STATUS_NO_MORE_ENTRIES)
 351             break;
 352         if (status)
 353         {
 354             SetLastError( RtlNtStatusToDosError( status ) );
 355             return FALSE;
 356         }
 357         ret = func(name, lparam);
 358     }
 359     return ret;
 360 }
 361
 362
 363 /***********************************************************************
 364  *              GetUserObjectInformationA   (USER32.@)
 365  */
 366 BOOL WINAPI GetUserObjectInformationA( HANDLE handle, INT index, LPVOID info, DWORD len, LPDWORD needed )
 367 {
 368     /* check for information types returning strings */
 369     if (index == UOI_TYPE || index == UOI_NAME)
 370     {
 371         WCHAR buffer[MAX_PATH];
 372         DWORD lenA, lenW;
 373
 374         if (!NtUserGetObjectInformation( handle, index, buffer, sizeof(buffer), &lenW )) return FALSE;
 375         lenA = WideCharToMultiByte( CP_ACP, 0, buffer, -1, NULL, 0, NULL, NULL );
 376         if (needed) *needed = lenA;
 377         if (lenA > len)
 378         {
 379             /* If the buffer length supplied by the caller is insufficient, Windows returns a
 380                'needed' length based upon the Unicode byte length, so we should do similarly. */
 381             if (needed) *needed = lenW;
 382
 383             SetLastError( ERROR_INSUFFICIENT_BUFFER );
 384             return FALSE;
 385         }
 386         if (info) WideCharToMultiByte( CP_ACP, 0, buffer, -1, info, len, NULL, NULL );
 387         return TRUE;
 388     }
 389     return NtUserGetObjectInformation( handle, index, info, len, needed );
 390 }
 391
 392
 393 /******************************************************************************
 394  *              SetUserObjectInformationA   (USER32.@)
 395  */
 396 BOOL WINAPI SetUserObjectInformationA( HANDLE handle, INT index, LPVOID info, DWORD len )
 397 {
 398     return NtUserSetObjectInformation( handle, index, info, len );
 399 }
 400
 401
 402 /***********************************************************************
 403  *              GetUserObjectSecurity   (USER32.@)
 404  */
 405 BOOL WINAPI GetUserObjectSecurity( HANDLE handle, PSECURITY_INFORMATION info,
 406                                    PSECURITY_DESCRIPTOR sid, DWORD len, LPDWORD needed )
 407 {
 408     FIXME( "(%p %p %p len=%ld %p),stub!\n", handle, info, sid, len, needed );
 409     if (needed)
 410         *needed = sizeof(SECURITY_DESCRIPTOR);
 411     if (len < sizeof(SECURITY_DESCRIPTOR))
 412     {
 413         SetLastError( ERROR_INSUFFICIENT_BUFFER );
 414         return FALSE;
 415     }
 416     return InitializeSecurityDescriptor(sid, SECURITY_DESCRIPTOR_REVISION);
 417 }
 418
 419 /***********************************************************************
 420  *              SetUserObjectSecurity   (USER32.@)
 421  */
 422 BOOL WINAPI SetUserObjectSecurity( HANDLE handle, PSECURITY_INFORMATION info,
 423                                    PSECURITY_DESCRIPTOR sid )
 424 {
 425     FIXME( "(%p,%p,%p),stub!\n", handle, info, sid );
 426     return TRUE;
 427 }