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 <stdarg.h>
  22 #include "windef.h"
  23 #include "winbase.h"
  24 #include "winnls.h"
  25 #include "winerror.h"
  26 #include "wingdi.h"
  27 #include "winuser.h"
  28 #include "wine/server.h"
  29 #include "wine/unicode.h"
  30 #include "wine/debug.h"
  31 #include "user_private.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(winstation);
  34
  35
  36 /* callback for enumeration functions */
  37 struct enum_proc_lparam
  38 {
  39     NAMEENUMPROCA func;
  40     LPARAM        lparam;
  41 };
  42
  43 static BOOL CALLBACK enum_names_WtoA( LPWSTR name, LPARAM lparam )
  44 {
  45     struct enum_proc_lparam *data = (struct enum_proc_lparam *)lparam;
  46     char buffer[MAX_PATH];
  47
  48     if (!WideCharToMultiByte( CP_ACP, 0, name, -1, buffer, sizeof(buffer), NULL, NULL ))
  49         return FALSE;
  50     return data->func( buffer, data->lparam );
  51 }
  52
  53
  54 /***********************************************************************
  55  *              CreateWindowStationA  (USER32.@)
  56  */
  57 HWINSTA WINAPI CreateWindowStationA( LPCSTR name, DWORD reserved, ACCESS_MASK access,
  58                                      LPSECURITY_ATTRIBUTES sa )
  59 {
  60     WCHAR buffer[MAX_PATH];
  61
  62     if (!name) return CreateWindowStationW( NULL, reserved, access, sa );
  63
  64     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
  65     {
  66         SetLastError( ERROR_FILENAME_EXCED_RANGE );
  67         return 0;
  68     }
  69     return CreateWindowStationW( buffer, reserved, access, sa );
  70 }
  71
  72
  73 /***********************************************************************
  74  *              CreateWindowStationW  (USER32.@)
  75  */
  76 HWINSTA WINAPI CreateWindowStationW( LPCWSTR name, DWORD reserved, ACCESS_MASK access,
  77                                      LPSECURITY_ATTRIBUTES sa )
  78 {
  79     HANDLE ret;
  80     DWORD len = name ? strlenW(name) : 0;
  81
  82     if (len >= MAX_PATH)
  83     {
  84         SetLastError( ERROR_FILENAME_EXCED_RANGE );
  85         return 0;
  86     }
  87     SERVER_START_REQ( create_winstation )
  88     {
  89         req->flags      = 0;
  90         req->access     = access;
  91         req->attributes = OBJ_CASE_INSENSITIVE | OBJ_OPENIF |
  92                           ((sa && sa->bInheritHandle) ? OBJ_INHERIT : 0);
  93         wine_server_add_data( req, name, len * sizeof(WCHAR) );
  94         /* it doesn't seem to set last error */
  95         wine_server_call( req );
  96         ret = reply->handle;
  97     }
  98     SERVER_END_REQ;
  99     return ret;
 100 }
 101
 102
 103 /******************************************************************************
 104  *              OpenWindowStationA  (USER32.@)
 105  */
 106 HWINSTA WINAPI OpenWindowStationA( LPCSTR name, BOOL inherit, ACCESS_MASK access )
 107 {
 108     WCHAR buffer[MAX_PATH];
 109
 110     if (!name) return OpenWindowStationW( NULL, inherit, access );
 111
 112     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 113     {
 114         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 115         return 0;
 116     }
 117     return OpenWindowStationW( buffer, inherit, access );
 118 }
 119
 120
 121 /******************************************************************************
 122  *              OpenWindowStationW  (USER32.@)
 123  */
 124 HWINSTA WINAPI OpenWindowStationW( LPCWSTR name, BOOL inherit, ACCESS_MASK access )
 125 {
 126     HANDLE ret = 0;
 127     DWORD len = name ? strlenW(name) : 0;
 128     if (len >= MAX_PATH)
 129     {
 130         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 131         return 0;
 132     }
 133     SERVER_START_REQ( open_winstation )
 134     {
 135         req->access     = access;
 136         req->attributes = OBJ_CASE_INSENSITIVE | (inherit ? OBJ_INHERIT : 0);
 137         wine_server_add_data( req, name, len * sizeof(WCHAR) );
 138         if (!wine_server_call_err( req )) ret = reply->handle;
 139     }
 140     SERVER_END_REQ;
 141     return ret;
 142 }
 143
 144
 145 /***********************************************************************
 146  *              CloseWindowStation  (USER32.@)
 147  */
 148 BOOL WINAPI CloseWindowStation( HWINSTA handle )
 149 {
 150     BOOL ret;
 151     SERVER_START_REQ( close_winstation )
 152     {
 153         req->handle = handle;
 154         ret = !wine_server_call_err( req );
 155     }
 156     SERVER_END_REQ;
 157     return ret;
 158 }
 159
 160
 161 /******************************************************************************
 162  *              GetProcessWindowStation  (USER32.@)
 163  */
 164 HWINSTA WINAPI GetProcessWindowStation(void)
 165 {
 166     HWINSTA ret = 0;
 167
 168     SERVER_START_REQ( get_process_winstation )
 169     {
 170         if (!wine_server_call_err( req )) ret = reply->handle;
 171     }
 172     SERVER_END_REQ;
 173     return ret;
 174 }
 175
 176
 177 /***********************************************************************
 178  *              SetProcessWindowStation  (USER32.@)
 179  */
 180 BOOL WINAPI SetProcessWindowStation( HWINSTA handle )
 181 {
 182     BOOL ret;
 183
 184     SERVER_START_REQ( set_process_winstation )
 185     {
 186         req->handle = handle;
 187         ret = !wine_server_call_err( req );
 188     }
 189     SERVER_END_REQ;
 190     return ret;
 191 }
 192
 193
 194 /******************************************************************************
 195  *              EnumWindowStationsA  (USER32.@)
 196  */
 197 BOOL WINAPI EnumWindowStationsA( WINSTAENUMPROCA func, LPARAM lparam )
 198 {
 199     struct enum_proc_lparam data;
 200     data.func   = func;
 201     data.lparam = lparam;
 202     return EnumWindowStationsW( enum_names_WtoA, (LPARAM)&data );
 203 }
 204
 205
 206 /******************************************************************************
 207  *              EnumWindowStationsA  (USER32.@)
 208  */
 209 BOOL WINAPI EnumWindowStationsW( WINSTAENUMPROCW func, LPARAM lparam )
 210 {
 211     FIXME( "(%p,%lx): stub\n", func, lparam );
 212     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 213     return FALSE;
 214 }
 215
 216
 217 /***********************************************************************
 218  *              CreateDesktopA   (USER32.@)
 219  */
 220 HDESK WINAPI CreateDesktopA( LPCSTR name, LPCSTR device, LPDEVMODEA devmode,
 221                              DWORD flags, ACCESS_MASK access, LPSECURITY_ATTRIBUTES sa )
 222 {
 223     WCHAR buffer[MAX_PATH];
 224
 225     if (device || devmode)
 226     {
 227         SetLastError( ERROR_INVALID_PARAMETER );
 228         return 0;
 229     }
 230     if (!name) return CreateDesktopW( NULL, NULL, NULL, flags, access, sa );
 231
 232     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 233     {
 234         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 235         return 0;
 236     }
 237     return CreateDesktopW( buffer, NULL, NULL, flags, access, sa );
 238 }
 239
 240
 241 /***********************************************************************
 242  *              CreateDesktopW   (USER32.@)
 243  */
 244 HDESK WINAPI CreateDesktopW( LPCWSTR name, LPCWSTR device, LPDEVMODEW devmode,
 245                              DWORD flags, ACCESS_MASK access, LPSECURITY_ATTRIBUTES sa )
 246 {
 247     HANDLE ret;
 248     DWORD len = name ? strlenW(name) : 0;
 249
 250     if (device || devmode)
 251     {
 252         SetLastError( ERROR_INVALID_PARAMETER );
 253         return 0;
 254     }
 255     if (len >= MAX_PATH)
 256     {
 257         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 258         return 0;
 259     }
 260     SERVER_START_REQ( create_desktop )
 261     {
 262         req->flags      = flags;
 263         req->access     = access;
 264         req->attributes = OBJ_CASE_INSENSITIVE | OBJ_OPENIF |
 265                           ((sa && sa->bInheritHandle) ? OBJ_INHERIT : 0);
 266         wine_server_add_data( req, name, len * sizeof(WCHAR) );
 267         /* it doesn't seem to set last error */
 268         wine_server_call( req );
 269         ret = reply->handle;
 270     }
 271     SERVER_END_REQ;
 272     return ret;
 273 }
 274
 275
 276 /******************************************************************************
 277  *              OpenDesktopA   (USER32.@)
 278  */
 279 HDESK WINAPI OpenDesktopA( LPCSTR name, DWORD flags, BOOL inherit, ACCESS_MASK access )
 280 {
 281     WCHAR buffer[MAX_PATH];
 282
 283     if (!name) return OpenDesktopW( NULL, flags, inherit, access );
 284
 285     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 286     {
 287         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 288         return 0;
 289     }
 290     return OpenDesktopW( buffer, flags, inherit, access );
 291 }
 292
 293
 294 /******************************************************************************
 295  *              OpenDesktopW   (USER32.@)
 296  */
 297 HDESK WINAPI OpenDesktopW( LPCWSTR name, DWORD flags, BOOL inherit, ACCESS_MASK access )
 298 {
 299     HANDLE ret = 0;
 300     DWORD len = name ? strlenW(name) : 0;
 301     if (len >= MAX_PATH)
 302     {
 303         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 304         return 0;
 305     }
 306     SERVER_START_REQ( open_desktop )
 307     {
 308         req->flags      = flags;
 309         req->access     = access;
 310         req->attributes = OBJ_CASE_INSENSITIVE | (inherit ? OBJ_INHERIT : 0);
 311         wine_server_add_data( req, name, len * sizeof(WCHAR) );
 312         if (!wine_server_call( req )) ret = reply->handle;
 313     }
 314     SERVER_END_REQ;
 315     return ret;
 316 }
 317
 318
 319 /***********************************************************************
 320  *              CloseDesktop  (USER32.@)
 321  */
 322 BOOL WINAPI CloseDesktop( HDESK handle )
 323 {
 324     BOOL ret;
 325     SERVER_START_REQ( close_desktop )
 326     {
 327         req->handle = handle;
 328         ret = !wine_server_call_err( req );
 329     }
 330     SERVER_END_REQ;
 331     return ret;
 332 }
 333
 334
 335 /******************************************************************************
 336  *              GetThreadDesktop   (USER32.@)
 337  */
 338 HDESK WINAPI GetThreadDesktop( DWORD thread )
 339 {
 340     HDESK ret = 0;
 341
 342     SERVER_START_REQ( get_thread_desktop )
 343     {
 344         req->tid = thread;
 345         if (!wine_server_call_err( req )) ret = reply->handle;
 346     }
 347     SERVER_END_REQ;
 348     return ret;
 349 }
 350
 351
 352 /******************************************************************************
 353  *              SetThreadDesktop   (USER32.@)
 354  */
 355 BOOL WINAPI SetThreadDesktop( HDESK handle )
 356 {
 357     BOOL ret;
 358
 359     SERVER_START_REQ( set_thread_desktop )
 360     {
 361         req->handle = handle;
 362         ret = !wine_server_call_err( req );
 363     }
 364     SERVER_END_REQ;
 365     if (ret) get_user_thread_info()->desktop = 0;  /* reset the desktop window */
 366     return ret;
 367 }
 368
 369
 370 /******************************************************************************
 371  *              EnumDesktopsA   (USER32.@)
 372  */
 373 BOOL WINAPI EnumDesktopsA( HWINSTA winsta, DESKTOPENUMPROCA func, LPARAM lparam )
 374 {
 375     struct enum_proc_lparam data;
 376     data.func   = func;
 377     data.lparam = lparam;
 378     return EnumDesktopsW( winsta, enum_names_WtoA, (LPARAM)&data );
 379 }
 380
 381
 382 /******************************************************************************
 383  *              EnumDesktopsW   (USER32.@)
 384  */
 385 BOOL WINAPI EnumDesktopsW( HWINSTA winsta, DESKTOPENUMPROCW func, LPARAM lparam )
 386 {
 387     FIXME( "(%p,%p,%lx): stub\n", winsta, func, lparam );
 388     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 389     return FALSE;
 390 }
 391
 392
 393 /******************************************************************************
 394  *              OpenInputDesktop   (USER32.@)
 395  */
 396 HDESK WINAPI OpenInputDesktop( DWORD flags, BOOL inherit, ACCESS_MASK access )
 397 {
 398     FIXME( "(%x,%i,%x): stub\n", flags, inherit, access );
 399     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 400     return 0;
 401 }
 402
 403
 404 /***********************************************************************
 405  *              EnumDesktopWindows   (USER32.@)
 406  */
 407 BOOL WINAPI EnumDesktopWindows( HDESK desktop, WNDENUMPROC func, LPARAM lparam )
 408 {
 409     FIXME( "(%p,%p,0x%lx): stub!\n", desktop, func, lparam );
 410     return TRUE;
 411 }
 412
 413
 414 /***********************************************************************
 415  *              GetUserObjectInformationA   (USER32.@)
 416  */
 417 BOOL WINAPI GetUserObjectInformationA( HANDLE handle, INT index, LPVOID info, DWORD len, LPDWORD needed )
 418 {
 419     /* check for information types returning strings */
 420     if (index == UOI_TYPE || index == UOI_NAME)
 421     {
 422         WCHAR buffer[MAX_PATH];
 423         DWORD lenA;
 424
 425         if (!GetUserObjectInformationW( handle, index, buffer, sizeof(buffer), NULL )) return FALSE;
 426         lenA = WideCharToMultiByte( CP_ACP, 0, buffer, -1, NULL, 0, NULL, NULL );
 427         if (needed) *needed = lenA;
 428         if (lenA > len)
 429         {
 430             SetLastError( ERROR_MORE_DATA );
 431             return FALSE;
 432         }
 433         if (info) WideCharToMultiByte( CP_ACP, 0, buffer, -1, info, len, NULL, NULL );
 434         return TRUE;
 435     }
 436     return GetUserObjectInformationW( handle, index, info, len, needed );
 437 }
 438
 439
 440 /***********************************************************************
 441  *              GetUserObjectInformationW   (USER32.@)
 442  */
 443 BOOL WINAPI GetUserObjectInformationW( HANDLE handle, INT index, LPVOID info, DWORD len, LPDWORD needed )
 444 {
 445     static const WCHAR desktopW[] = { 'D','e','s','k','t','o','p',0 };
 446     static const WCHAR winstationW[] = { 'W','i','n','d','o','w','S','t','a','t','i','o','n',0 };
 447     BOOL ret;
 448
 449     switch(index)
 450     {
 451     case UOI_FLAGS:
 452         {
 453             USEROBJECTFLAGS *obj_flags = info;
 454             if (needed) *needed = sizeof(*obj_flags);
 455             if (len < sizeof(*obj_flags))
 456             {
 457                 SetLastError( ERROR_BUFFER_OVERFLOW );
 458                 return FALSE;
 459             }
 460             SERVER_START_REQ( set_user_object_info )
 461             {
 462                 req->handle    = handle;
 463                 req->flags     = 0;
 464                 ret = !wine_server_call_err( req );
 465                 if (ret)
 466                 {
 467                     /* FIXME: inherit flag */
 468                     obj_flags->dwFlags = reply->old_obj_flags;
 469                 }
 470             }
 471             SERVER_END_REQ;
 472         }
 473         return ret;
 474
 475     case UOI_TYPE:
 476         SERVER_START_REQ( set_user_object_info )
 477         {
 478             req->handle = handle;
 479             req->flags  = 0;
 480             ret = !wine_server_call_err( req );
 481             if (ret)
 482             {
 483                 size_t size = reply->is_desktop ? sizeof(desktopW) : sizeof(winstationW);
 484                 if (needed) *needed = size;
 485                 if (len < size)
 486                 {
 487                     SetLastError( ERROR_MORE_DATA );
 488                     ret = FALSE;
 489                 }
 490                 else memcpy( info, reply->is_desktop ? desktopW : winstationW, size );
 491             }
 492         }
 493         SERVER_END_REQ;
 494         return ret;
 495
 496     case UOI_NAME:
 497         {
 498             WCHAR buffer[MAX_PATH];
 499             SERVER_START_REQ( set_user_object_info )
 500             {
 501                 req->handle = handle;
 502                 req->flags  = 0;
 503                 wine_server_set_reply( req, buffer, sizeof(buffer) - sizeof(WCHAR) );
 504                 ret = !wine_server_call_err( req );
 505                 if (ret)
 506                 {
 507                     size_t size = wine_server_reply_size( reply );
 508                     buffer[size / sizeof(WCHAR)] = 0;
 509                     size += sizeof(WCHAR);
 510                     if (needed) *needed = size;
 511                     if (len < size)
 512                     {
 513                         SetLastError( ERROR_MORE_DATA );
 514                         ret = FALSE;
 515                     }
 516                     else memcpy( info, buffer, size );
 517                 }
 518             }
 519             SERVER_END_REQ;
 520         }
 521         return ret;
 522
 523     case UOI_USER_SID:
 524         FIXME( "not supported index %d\n", index );
 525         /* fall through */
 526     default:
 527         SetLastError( ERROR_INVALID_PARAMETER );
 528         return FALSE;
 529     }
 530 }
 531
 532
 533 /******************************************************************************
 534  *              SetUserObjectInformationA   (USER32.@)
 535  */
 536 BOOL WINAPI SetUserObjectInformationA( HANDLE handle, INT index, LPVOID info, DWORD len )
 537 {
 538     return SetUserObjectInformationW( handle, index, info, len );
 539 }
 540
 541
 542 /******************************************************************************
 543  *              SetUserObjectInformationW   (USER32.@)
 544  */
 545 BOOL WINAPI SetUserObjectInformationW( HANDLE handle, INT index, LPVOID info, DWORD len )
 546 {
 547     BOOL ret;
 548     const USEROBJECTFLAGS *obj_flags = info;
 549
 550     if (index != UOI_FLAGS || !info || len < sizeof(*obj_flags))
 551     {
 552         SetLastError( ERROR_INVALID_PARAMETER );
 553         return FALSE;
 554     }
 555     /* FIXME: inherit flag */
 556     SERVER_START_REQ( set_user_object_info )
 557     {
 558         req->handle    = handle;
 559         req->flags     = SET_USER_OBJECT_FLAGS;
 560         req->obj_flags = obj_flags->dwFlags;
 561         ret = !wine_server_call_err( req );
 562     }
 563     SERVER_END_REQ;
 564     return ret;
 565 }
 566
 567
 568 /***********************************************************************
 569  *              GetUserObjectSecurity   (USER32.@)
 570  */
 571 BOOL WINAPI GetUserObjectSecurity( HANDLE handle, PSECURITY_INFORMATION info,
 572                                    PSECURITY_DESCRIPTOR sid, DWORD len, LPDWORD needed )
 573 {
 574     FIXME( "(%p %p %p len=%d %p),stub!\n", handle, info, sid, len, needed );
 575     return TRUE;
 576 }
 577
 578 /***********************************************************************
 579  *              SetUserObjectSecurity   (USER32.@)
 580  */
 581 BOOL WINAPI SetUserObjectSecurity( HANDLE handle, PSECURITY_INFORMATION info,
 582                                    PSECURITY_DESCRIPTOR sid )
 583 {
 584     FIXME( "(%p,%p,%p),stub!\n", handle, info, sid );
 585     return TRUE;
 586 }