dlls/kernel32/console.c

   1 /*
   2  * Win32 console functions
   3  *
   4  * Copyright 1995 Martin von Loewis and Cameron Heide
   5  * Copyright 1997 Karl Garrison
   6  * Copyright 1998 John Richardson
   7  * Copyright 1998 Marcus Meissner
   8  * Copyright 2001,2002,2004,2005,2010 Eric Pouech
   9  * Copyright 2001 Alexandre Julliard
  10  *
  11  * This library is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2.1 of the License, or (at your option) any later version.
  15  *
  16  * This library is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with this library; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  24  */
  25
  26 #include <stdarg.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include <limits.h>
  30
  31 #define NONAMELESSUNION
  32 #include "ntstatus.h"
  33 #define WIN32_NO_STATUS
  34 #include "windef.h"
  35 #include "winbase.h"
  36 #include "winnls.h"
  37 #include "winerror.h"
  38 #include "wincon.h"
  39 #include "wine/condrv.h"
  40 #include "wine/server.h"
  41 #include "wine/exception.h"
  42 #include "wine/debug.h"
  43 #include "excpt.h"
  44 #include "kernel_private.h"
  45
  46 WINE_DEFAULT_DEBUG_CHANNEL(console);
  47
  48 static const WCHAR coninW[] = {'C','O','N','I','N','$',0};
  49 static const WCHAR conoutW[] = {'C','O','N','O','U','T','$',0};
  50
  51 /******************************************************************************
  52  * GetConsoleWindow [KERNEL32.@] Get hwnd of the console window.
  53  *
  54  * RETURNS
  55  *   Success: hwnd of the console window.
  56  *   Failure: NULL
  57  */
  58 HWND WINAPI GetConsoleWindow(void)
  59 {
  60     struct condrv_input_info info;
  61     BOOL ret;
  62
  63     ret = DeviceIoControl( RtlGetCurrentPeb()->ProcessParameters->ConsoleHandle,
  64                            IOCTL_CONDRV_GET_INPUT_INFO, NULL, 0, &info, sizeof(info), NULL, NULL );
  65     return ret ? wine_server_ptr_handle(info.win) : NULL;
  66 }
  67
  68
  69 /******************************************************************
  70  *              OpenConsoleW            (KERNEL32.@)
  71  *
  72  * Undocumented
  73  *      Open a handle to the current process console.
  74  *      Returns INVALID_HANDLE_VALUE on failure.
  75  */
  76 HANDLE WINAPI OpenConsoleW(LPCWSTR name, DWORD access, BOOL inherit, DWORD creation)
  77 {
  78     SECURITY_ATTRIBUTES sa;
  79
  80     TRACE("(%s, 0x%08x, %d, %u)\n", debugstr_w(name), access, inherit, creation);
  81
  82     if (!name || (wcsicmp( coninW, name ) && wcsicmp( conoutW, name )) || creation != OPEN_EXISTING)
  83     {
  84         SetLastError( ERROR_INVALID_PARAMETER );
  85         return INVALID_HANDLE_VALUE;
  86     }
  87
  88     sa.nLength = sizeof(sa);
  89     sa.lpSecurityDescriptor = NULL;
  90     sa.bInheritHandle = inherit;
  91
  92     return CreateFileW( name, access, FILE_SHARE_READ | FILE_SHARE_WRITE, &sa, creation, 0, NULL );
  93 }
  94
  95 /******************************************************************
  96  *              VerifyConsoleIoHandle            (KERNEL32.@)
  97  *
  98  * Undocumented
  99  */
 100 BOOL WINAPI VerifyConsoleIoHandle(HANDLE handle)
 101 {
 102     IO_STATUS_BLOCK io;
 103     DWORD mode;
 104     return !NtDeviceIoControlFile( handle, NULL, NULL, NULL, &io, IOCTL_CONDRV_GET_MODE,
 105                                    NULL, 0, &mode, sizeof(mode) );
 106 }
 107
 108 /******************************************************************
 109  *              DuplicateConsoleHandle            (KERNEL32.@)
 110  *
 111  * Undocumented
 112  */
 113 HANDLE WINAPI DuplicateConsoleHandle(HANDLE handle, DWORD access, BOOL inherit,
 114                                      DWORD options)
 115 {
 116     HANDLE ret;
 117     return DuplicateHandle(GetCurrentProcess(), handle, GetCurrentProcess(), &ret,
 118                            access, inherit, options) ? ret : INVALID_HANDLE_VALUE;
 119 }
 120
 121 /******************************************************************
 122  *              CloseConsoleHandle            (KERNEL32.@)
 123  *
 124  * Undocumented
 125  */
 126 BOOL WINAPI CloseConsoleHandle(HANDLE handle)
 127 {
 128     return CloseHandle(handle);
 129 }
 130
 131 /******************************************************************
 132  *              GetConsoleInputWaitHandle            (KERNEL32.@)
 133  *
 134  * Undocumented
 135  */
 136 HANDLE WINAPI GetConsoleInputWaitHandle(void)
 137 {
 138     return GetStdHandle( STD_INPUT_HANDLE );
 139 }
 140
 141
 142 /***********************************************************************
 143  *            SetConsoleTitleA   (KERNEL32.@)
 144  */
 145 BOOL WINAPI SetConsoleTitleA( LPCSTR title )
 146 {
 147     LPWSTR titleW;
 148     BOOL ret;
 149
 150     DWORD len = MultiByteToWideChar( GetConsoleOutputCP(), 0, title, -1, NULL, 0 );
 151     if (!(titleW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)))) return FALSE;
 152     MultiByteToWideChar( GetConsoleOutputCP(), 0, title, -1, titleW, len );
 153     ret = SetConsoleTitleW(titleW);
 154     HeapFree(GetProcessHeap(), 0, titleW);
 155     return ret;
 156 }
 157
 158
 159 /***********************************************************************
 160  *            GetConsoleKeyboardLayoutNameA   (KERNEL32.@)
 161  */
 162 BOOL WINAPI GetConsoleKeyboardLayoutNameA(LPSTR layoutName)
 163 {
 164     FIXME( "stub %p\n", layoutName);
 165     return TRUE;
 166 }
 167
 168 /***********************************************************************
 169  *            GetConsoleKeyboardLayoutNameW   (KERNEL32.@)
 170  */
 171 BOOL WINAPI GetConsoleKeyboardLayoutNameW(LPWSTR layoutName)
 172 {
 173     static int once;
 174     if (!once++)
 175         FIXME( "stub %p\n", layoutName);
 176     return TRUE;
 177 }
 178
 179 /***********************************************************************
 180  *            GetConsoleTitleA   (KERNEL32.@)
 181  *
 182  * See GetConsoleTitleW.
 183  */
 184 DWORD WINAPI GetConsoleTitleA(LPSTR title, DWORD size)
 185 {
 186     WCHAR *ptr = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * size);
 187     DWORD ret;
 188
 189     if (!ptr) return 0;
 190     ret = GetConsoleTitleW( ptr, size );
 191     if (ret)
 192     {
 193         WideCharToMultiByte( GetConsoleOutputCP(), 0, ptr, ret + 1, title, size, NULL, NULL);
 194         ret = strlen(title);
 195     }
 196     HeapFree(GetProcessHeap(), 0, ptr);
 197     return ret;
 198 }
 199
 200
 201 /***********************************************************************
 202  *            GetNumberOfConsoleMouseButtons   (KERNEL32.@)
 203  */
 204 BOOL WINAPI GetNumberOfConsoleMouseButtons(LPDWORD nrofbuttons)
 205 {
 206     FIXME("(%p): stub\n", nrofbuttons);
 207     *nrofbuttons = 2;
 208     return TRUE;
 209 }
 210
 211
 212 /******************************************************************
 213  *              GetConsoleDisplayMode  (KERNEL32.@)
 214  */
 215 BOOL WINAPI GetConsoleDisplayMode(LPDWORD lpModeFlags)
 216 {
 217     TRACE("semi-stub: %p\n", lpModeFlags);
 218     /* It is safe to successfully report windowed mode */
 219     *lpModeFlags = 0;
 220     return TRUE;
 221 }
 222
 223 /******************************************************************
 224  *              SetConsoleDisplayMode  (KERNEL32.@)
 225  */
 226 BOOL WINAPI SetConsoleDisplayMode(HANDLE hConsoleOutput, DWORD dwFlags,
 227                                   COORD *lpNewScreenBufferDimensions)
 228 {
 229     TRACE("(%p, %x, (%d, %d))\n", hConsoleOutput, dwFlags,
 230           lpNewScreenBufferDimensions->X, lpNewScreenBufferDimensions->Y);
 231     if (dwFlags == 1)
 232     {
 233         /* We cannot switch to fullscreen */
 234         return FALSE;
 235     }
 236     return TRUE;
 237 }
 238
 239 /******************************************************************
 240  *              GetConsoleAliasW
 241  *
 242  *
 243  * RETURNS
 244  *    0 if an error occurred, non-zero for success
 245  *
 246  */
 247 DWORD WINAPI GetConsoleAliasW(LPWSTR lpSource, LPWSTR lpTargetBuffer,
 248                               DWORD TargetBufferLength, LPWSTR lpExename)
 249 {
 250     FIXME("(%s,%p,%d,%s): stub\n", debugstr_w(lpSource), lpTargetBuffer, TargetBufferLength, debugstr_w(lpExename));
 251     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 252     return 0;
 253 }
 254
 255 /******************************************************************
 256  *              GetConsoleProcessList  (KERNEL32.@)
 257  */
 258 DWORD WINAPI GetConsoleProcessList(LPDWORD processlist, DWORD processcount)
 259 {
 260     FIXME("(%p,%d): stub\n", processlist, processcount);
 261
 262     if (!processlist || processcount < 1)
 263     {
 264         SetLastError(ERROR_INVALID_PARAMETER);
 265         return 0;
 266     }
 267
 268     return 0;
 269 }
 270
 271 BOOL CONSOLE_Init(RTL_USER_PROCESS_PARAMETERS *params)
 272 {
 273     /* convert value from server:
 274      * + INVALID_HANDLE_VALUE => TEB: 0, STARTUPINFO: INVALID_HANDLE_VALUE
 275      * + 0                    => TEB: 0, STARTUPINFO: INVALID_HANDLE_VALUE
 276      * + console handle needs to be mapped
 277      */
 278     if (!params->hStdInput || params->hStdInput == INVALID_HANDLE_VALUE)
 279         params->hStdInput = 0;
 280     else if (!is_console_handle(params->hStdInput) && VerifyConsoleIoHandle(params->hStdInput))
 281         params->hStdInput = console_handle_map(params->hStdInput);
 282
 283     if (!params->hStdOutput || params->hStdOutput == INVALID_HANDLE_VALUE)
 284         params->hStdOutput = 0;
 285     else if (!is_console_handle(params->hStdOutput) && VerifyConsoleIoHandle(params->hStdOutput))
 286         params->hStdOutput = console_handle_map(params->hStdOutput);
 287
 288     if (!params->hStdError || params->hStdError == INVALID_HANDLE_VALUE)
 289         params->hStdError = 0;
 290     else if (!is_console_handle(params->hStdError) && VerifyConsoleIoHandle(params->hStdError))
 291         params->hStdError = console_handle_map(params->hStdError);
 292
 293     return TRUE;
 294 }
 295
 296 /* Undocumented, called by native doskey.exe */
 297 /* FIXME: Should use CONSOLE_GetHistory() above for full implementation */
 298 DWORD WINAPI GetConsoleCommandHistoryA(DWORD unknown1, DWORD unknown2, DWORD unknown3)
 299 {
 300     FIXME(": (0x%x, 0x%x, 0x%x) stub!\n", unknown1, unknown2, unknown3);
 301     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 302     return 0;
 303 }
 304
 305 /* Undocumented, called by native doskey.exe */
 306 /* FIXME: Should use CONSOLE_GetHistory() above for full implementation */
 307 DWORD WINAPI GetConsoleCommandHistoryW(DWORD unknown1, DWORD unknown2, DWORD unknown3)
 308 {
 309     FIXME(": (0x%x, 0x%x, 0x%x) stub!\n", unknown1, unknown2, unknown3);
 310     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 311     return 0;
 312 }
 313
 314 /* Undocumented, called by native doskey.exe */
 315 /* FIXME: Should use CONSOLE_GetHistory() above for full implementation */
 316 DWORD WINAPI GetConsoleCommandHistoryLengthA(LPCSTR unknown)
 317 {
 318     FIXME(": (%s) stub!\n", debugstr_a(unknown));
 319     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 320     return 0;
 321 }
 322
 323 /* Undocumented, called by native doskey.exe */
 324 /* FIXME: Should use CONSOLE_GetHistory() above for full implementation */
 325 DWORD WINAPI GetConsoleCommandHistoryLengthW(LPCWSTR unknown)
 326 {
 327     FIXME(": (%s) stub!\n", debugstr_w(unknown));
 328     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 329     return 0;
 330 }
 331
 332 DWORD WINAPI GetConsoleAliasesLengthA(LPSTR unknown)
 333 {
 334     FIXME(": (%s) stub!\n", debugstr_a(unknown));
 335     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 336     return 0;
 337 }
 338
 339 DWORD WINAPI GetConsoleAliasesLengthW(LPWSTR unknown)
 340 {
 341     FIXME(": (%s) stub!\n", debugstr_w(unknown));
 342     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 343     return 0;
 344 }
 345
 346 DWORD WINAPI GetConsoleAliasExesLengthA(void)
 347 {
 348     FIXME(": stub!\n");
 349     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 350     return 0;
 351 }
 352
 353 DWORD WINAPI GetConsoleAliasExesLengthW(void)
 354 {
 355     FIXME(": stub!\n");
 356     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 357     return 0;
 358 }
 359
 360 VOID WINAPI ExpungeConsoleCommandHistoryA(LPCSTR unknown)
 361 {
 362     FIXME(": (%s) stub!\n", debugstr_a(unknown));
 363     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 364 }
 365
 366 VOID WINAPI ExpungeConsoleCommandHistoryW(LPCWSTR unknown)
 367 {
 368     FIXME(": (%s) stub!\n", debugstr_w(unknown));
 369     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 370 }
 371
 372 BOOL WINAPI AddConsoleAliasA(LPSTR source, LPSTR target, LPSTR exename)
 373 {
 374     FIXME(": (%s, %s, %s) stub!\n", debugstr_a(source), debugstr_a(target), debugstr_a(exename));
 375     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 376     return FALSE;
 377 }
 378
 379 BOOL WINAPI AddConsoleAliasW(LPWSTR source, LPWSTR target, LPWSTR exename)
 380 {
 381     FIXME(": (%s, %s, %s) stub!\n", debugstr_w(source), debugstr_w(target), debugstr_w(exename));
 382     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 383     return FALSE;
 384 }
 385
 386
 387 BOOL WINAPI SetConsoleIcon(HICON icon)
 388 {
 389     FIXME(": (%p) stub!\n", icon);
 390     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 391     return FALSE;
 392 }
 393
 394 DWORD WINAPI GetNumberOfConsoleFonts(void)
 395 {
 396     return 1;
 397 }
 398
 399 BOOL WINAPI SetConsoleFont(HANDLE hConsole, DWORD index)
 400 {
 401     FIXME("(%p, %u): stub!\n", hConsole, index);
 402     SetLastError(LOWORD(E_NOTIMPL) /* win10 1709+ */);
 403     return FALSE;
 404 }
 405
 406 BOOL WINAPI SetConsoleKeyShortcuts(BOOL set, BYTE keys, VOID *a, DWORD b)
 407 {
 408     FIXME(": (%u %u %p %u) stub!\n", set, keys, a, b);
 409     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 410     return FALSE;
 411 }
 412
 413
 414 BOOL WINAPI GetCurrentConsoleFontEx(HANDLE hConsole, BOOL maxwindow, CONSOLE_FONT_INFOEX *fontinfo)
 415 {
 416     DWORD size;
 417     struct
 418     {
 419         struct condrv_output_info info;
 420         WCHAR face_name[LF_FACESIZE - 1];
 421     } data;
 422
 423     if (fontinfo->cbSize != sizeof(CONSOLE_FONT_INFOEX))
 424     {
 425         SetLastError(ERROR_INVALID_PARAMETER);
 426         return FALSE;
 427     }
 428
 429     if (!DeviceIoControl( hConsole, IOCTL_CONDRV_GET_OUTPUT_INFO, NULL, 0,
 430                           &data, sizeof(data), &size, NULL ))
 431     {
 432         SetLastError( ERROR_INVALID_HANDLE );
 433         return FALSE;
 434     }
 435
 436     fontinfo->nFont = 0;
 437     if (maxwindow)
 438     {
 439         fontinfo->dwFontSize.X = min( data.info.width, data.info.max_width );
 440         fontinfo->dwFontSize.Y = min( data.info.height, data.info.max_height );
 441     }
 442     else
 443     {
 444         fontinfo->dwFontSize.X = data.info.win_right - data.info.win_left + 1;
 445         fontinfo->dwFontSize.Y = data.info.win_bottom - data.info.win_top + 1;
 446     }
 447     size -= sizeof(data.info);
 448     if (size) memcpy( fontinfo->FaceName, data.face_name, size );
 449     fontinfo->FaceName[size / sizeof(WCHAR)] = 0;
 450     fontinfo->FontFamily = data.info.font_pitch_family;
 451     fontinfo->FontWeight = data.info.font_weight;
 452     return TRUE;
 453 }
 454
 455 BOOL WINAPI GetCurrentConsoleFont(HANDLE hConsole, BOOL maxwindow, CONSOLE_FONT_INFO *fontinfo)
 456 {
 457     BOOL ret;
 458     CONSOLE_FONT_INFOEX res;
 459
 460     res.cbSize = sizeof(CONSOLE_FONT_INFOEX);
 461
 462     ret = GetCurrentConsoleFontEx(hConsole, maxwindow, &res);
 463     if(ret)
 464     {
 465         fontinfo->nFont = res.nFont;
 466         fontinfo->dwFontSize.X = res.dwFontSize.X;
 467         fontinfo->dwFontSize.Y = res.dwFontSize.Y;
 468     }
 469     return ret;
 470 }
 471
 472 static COORD get_console_font_size(HANDLE hConsole, DWORD index)
 473 {
 474     struct condrv_output_info info;
 475     COORD c = {0,0};
 476
 477     if (index >= GetNumberOfConsoleFonts())
 478     {
 479         SetLastError(ERROR_INVALID_PARAMETER);
 480         return c;
 481     }
 482
 483     if (DeviceIoControl( hConsole, IOCTL_CONDRV_GET_OUTPUT_INFO, NULL, 0, &info, sizeof(info), NULL, NULL ))
 484     {
 485         c.X = info.font_width;
 486         c.Y = info.font_height;
 487     }
 488     else SetLastError( ERROR_INVALID_HANDLE );
 489     return c;
 490 }
 491
 492 #if defined(__i386__) && !defined(__MINGW32__) && !defined(_MSC_VER)
 493 #undef GetConsoleFontSize
 494 DWORD WINAPI GetConsoleFontSize(HANDLE hConsole, DWORD index)
 495 {
 496     union {
 497         COORD c;
 498         DWORD w;
 499     } x;
 500
 501     x.c = get_console_font_size(hConsole, index);
 502     return x.w;
 503 }
 504 #else
 505 COORD WINAPI GetConsoleFontSize(HANDLE hConsole, DWORD index)
 506 {
 507     return get_console_font_size(hConsole, index);
 508 }
 509 #endif /* !defined(__i386__) */
 510
 511 BOOL WINAPI GetConsoleFontInfo(HANDLE hConsole, BOOL maximize, DWORD numfonts, CONSOLE_FONT_INFO *info)
 512 {
 513     FIXME("(%p %d %u %p): stub!\n", hConsole, maximize, numfonts, info);
 514     SetLastError(LOWORD(E_NOTIMPL) /* win10 1709+ */);
 515     return FALSE;
 516 }
 517
 518 BOOL WINAPI SetCurrentConsoleFontEx(HANDLE hConsole, BOOL maxwindow, CONSOLE_FONT_INFOEX *cfix)
 519 {
 520     FIXME("(%p %d %p): stub!\n", hConsole, maxwindow, cfix);
 521     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 522     return FALSE;
 523 }