dll/win32/kernel32/client/console/alias.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS system libraries
   4  * FILE:            dll/win32/kernel32/client/console/console.c
   5  * PURPOSE:         Win32 server console functions
   6  * PROGRAMMERS:     David Welch (welch@cwcom.net) (welch@mcmail.com)
   7  *                  Christoph von Wittich (christoph_vw@reactos.org)
   8  *                  Johannes Anderwald (janderwald@reactos.org)
   9  */
  10
  11 /* INCLUDES *******************************************************************/
  12
  13 #include <k32.h>
  14
  15 #define NDEBUG
  16 #include <debug.h>
  17
  18 /* FUNCTIONS ******************************************************************/
  19
  20 /*
  21  * @unimplemented
  22  */
  23 BOOL
  24 WINAPI
  25 AddConsoleAliasW(LPCWSTR lpSource,
  26                  LPCWSTR lpTarget,
  27                  LPCWSTR lpExeName)
  28 {
  29     PCSR_API_MESSAGE Request;
  30     NTSTATUS Status;
  31     ULONG SourceLength;
  32     ULONG TargetLength = 0;
  33     ULONG ExeLength;
  34     ULONG Size;
  35     ULONG RequestLength;
  36     WCHAR * Ptr;
  37
  38     DPRINT("AddConsoleAliasW enterd with lpSource %S lpTarget %S lpExeName %S\n", lpSource, lpTarget, lpExeName);
  39
  40     ExeLength = wcslen(lpExeName) + 1;
  41     SourceLength = wcslen(lpSource)+ 1;
  42     if (lpTarget)
  43         TargetLength = wcslen(lpTarget) + 1;
  44
  45     Size = (ExeLength + SourceLength + TargetLength) * sizeof(WCHAR);
  46     RequestLength = sizeof(CSR_API_MESSAGE) + Size;
  47
  48     Request = RtlAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY, RequestLength);
  49     Ptr = (WCHAR*)(((ULONG_PTR)Request) + sizeof(CSR_API_MESSAGE));
  50
  51     wcscpy(Ptr, lpSource);
  52     Request->Data.AddConsoleAlias.SourceLength = SourceLength;
  53     Ptr = (WCHAR*)(((ULONG_PTR)Request) + sizeof(CSR_API_MESSAGE) + SourceLength * sizeof(WCHAR));
  54
  55     wcscpy(Ptr, lpExeName);
  56     Request->Data.AddConsoleAlias.ExeLength = ExeLength;
  57     Ptr = (WCHAR*)(((ULONG_PTR)Request) + sizeof(CSR_API_MESSAGE) + (ExeLength + SourceLength)* sizeof(WCHAR));
  58
  59     if (lpTarget) /* target can be optional */
  60         wcscpy(Ptr, lpTarget);
  61
  62     Request->Data.AddConsoleAlias.TargetLength = TargetLength;
  63
  64     Status = CsrClientCallServer(Request,
  65                                  NULL,
  66                                  CSR_CREATE_API_NUMBER(CSR_CONSOLE, ADD_CONSOLE_ALIAS),
  67                                  RequestLength);
  68
  69     if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request->Status))
  70     {
  71         BaseSetLastNTError(Status);
  72         RtlFreeHeap(GetProcessHeap(), 0, Request);
  73         return FALSE;
  74     }
  75
  76     RtlFreeHeap(GetProcessHeap(), 0, Request);
  77     return TRUE;
  78 }
  79
  80
  81 /*
  82  * @implemented
  83  */
  84 BOOL
  85 WINAPI
  86 AddConsoleAliasA(LPCSTR lpSource,
  87                  LPCSTR lpTarget,
  88                  LPCSTR lpExeName)
  89 {
  90     LPWSTR lpSourceW = NULL;
  91     LPWSTR lpTargetW = NULL;
  92     LPWSTR lpExeNameW = NULL;
  93     BOOL bRetVal;
  94
  95     if (lpSource)
  96         BasepAnsiStringToHeapUnicodeString(lpSource, (LPWSTR*) &lpSourceW);
  97     if (lpTarget)
  98         BasepAnsiStringToHeapUnicodeString(lpTarget, (LPWSTR*) &lpTargetW);
  99     if (lpExeName)
 100         BasepAnsiStringToHeapUnicodeString(lpExeName, (LPWSTR*) &lpExeNameW);
 101
 102     bRetVal = AddConsoleAliasW(lpSourceW, lpTargetW, lpExeNameW);
 103
 104     /* Clean up */
 105     if (lpSourceW)
 106         RtlFreeHeap(GetProcessHeap(), 0, (LPWSTR*) lpSourceW);
 107     if (lpTargetW)
 108         RtlFreeHeap(GetProcessHeap(), 0, (LPWSTR*) lpTargetW);
 109     if (lpExeNameW)
 110         RtlFreeHeap(GetProcessHeap(), 0, (LPWSTR*) lpExeNameW);
 111
 112     return bRetVal;
 113 }
 114
 115
 116 /*
 117  * @implemented
 118  */
 119 DWORD
 120 WINAPI
 121 GetConsoleAliasW(LPWSTR lpSource,
 122                  LPWSTR lpTargetBuffer,
 123                  DWORD TargetBufferLength,
 124                  LPWSTR lpExeName)
 125 {
 126     PCSR_API_MESSAGE Request;
 127     PCSR_CAPTURE_BUFFER CaptureBuffer;
 128     NTSTATUS Status;
 129     ULONG Size;
 130     ULONG ExeLength;
 131     ULONG SourceLength;
 132     ULONG RequestLength;
 133     WCHAR * Ptr;
 134
 135     DPRINT("GetConsoleAliasW entered lpSource %S lpExeName %S\n", lpSource, lpExeName);
 136
 137     if (lpTargetBuffer == NULL)
 138     {
 139         SetLastError(ERROR_INVALID_PARAMETER);
 140         return 0;
 141     }
 142
 143     ExeLength = wcslen(lpExeName) + 1;
 144     SourceLength = wcslen(lpSource) + 1;
 145
 146     Size = (ExeLength + SourceLength) * sizeof(WCHAR);
 147
 148     RequestLength = Size + sizeof(CSR_API_MESSAGE);
 149     Request = RtlAllocateHeap(GetProcessHeap(), 0, RequestLength);
 150     if (Request == NULL)
 151     {
 152         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 153         return 0;
 154     }
 155
 156     CaptureBuffer = CsrAllocateCaptureBuffer(1, TargetBufferLength);
 157     if (!CaptureBuffer)
 158     {
 159         DPRINT1("CsrAllocateCaptureBuffer failed!\n");
 160         RtlFreeHeap(GetProcessHeap(), 0, Request);
 161         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 162         return 0;
 163     }
 164
 165     Request->Data.GetConsoleAlias.TargetBuffer = NULL;
 166
 167     CsrCaptureMessageBuffer(CaptureBuffer,
 168                             NULL,
 169                             TargetBufferLength,
 170                             (PVOID*)&Request->Data.GetConsoleAlias.TargetBuffer);
 171
 172     Request->Data.GetConsoleAlias.TargetBufferLength = TargetBufferLength;
 173
 174     Ptr = (LPWSTR)((ULONG_PTR)Request + sizeof(CSR_API_MESSAGE));
 175     wcscpy(Ptr, lpSource);
 176     Ptr += SourceLength;
 177     wcscpy(Ptr, lpExeName);
 178
 179     Request->Data.GetConsoleAlias.ExeLength = ExeLength;
 180     Request->Data.GetConsoleAlias.SourceLength = SourceLength;
 181
 182     Status = CsrClientCallServer(Request,
 183                                  CaptureBuffer,
 184                                  CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_CONSOLE_ALIAS),
 185                                  sizeof(CSR_API_MESSAGE) + Size);
 186
 187     if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request->Status))
 188     {
 189         RtlFreeHeap(GetProcessHeap(), 0, Request);
 190         CsrFreeCaptureBuffer(CaptureBuffer);
 191         BaseSetLastNTError(Status);
 192         return 0;
 193     }
 194
 195     wcscpy(lpTargetBuffer, Request->Data.GetConsoleAlias.TargetBuffer);
 196     RtlFreeHeap(GetProcessHeap(), 0, Request);
 197     CsrFreeCaptureBuffer(CaptureBuffer);
 198
 199     return Request->Data.GetConsoleAlias.BytesWritten;
 200 }
 201
 202
 203 /*
 204  * @implemented
 205  */
 206 DWORD
 207 WINAPI
 208 GetConsoleAliasA(LPSTR lpSource,
 209                  LPSTR lpTargetBuffer,
 210                  DWORD TargetBufferLength,
 211                  LPSTR lpExeName)
 212 {
 213     LPWSTR lpwSource;
 214     LPWSTR lpwExeName;
 215     LPWSTR lpwTargetBuffer;
 216     UINT dwSourceSize;
 217     UINT dwExeNameSize;
 218     UINT dwResult;
 219
 220     DPRINT("GetConsoleAliasA entered\n");
 221
 222     if (lpTargetBuffer == NULL)
 223     {
 224         SetLastError(ERROR_INVALID_PARAMETER);
 225         return 0;
 226     }
 227
 228     dwSourceSize = (strlen(lpSource)+1) * sizeof(WCHAR);
 229     lpwSource = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwSourceSize);
 230     if (lpwSource == NULL)
 231     {
 232         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 233         return 0;
 234     }
 235     MultiByteToWideChar(CP_ACP, 0, lpSource, -1, lpwSource, dwSourceSize);
 236
 237     dwExeNameSize = (strlen(lpExeName)+1) * sizeof(WCHAR);
 238     lpwExeName = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwExeNameSize);
 239     if (lpwExeName == NULL)
 240     {
 241         HeapFree(GetProcessHeap(), 0, lpwSource);
 242         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 243         return 0;
 244     }
 245     MultiByteToWideChar(CP_ACP, 0, lpExeName, -1, lpwExeName, dwExeNameSize);
 246
 247     lpwTargetBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, TargetBufferLength * sizeof(WCHAR));
 248     if (lpwTargetBuffer == NULL)
 249     {
 250         HeapFree(GetProcessHeap(), 0, lpwSource);
 251         HeapFree(GetProcessHeap(), 0, lpwExeName);
 252         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 253         return 0;
 254     }
 255
 256     dwResult = GetConsoleAliasW(lpwSource, lpwTargetBuffer, TargetBufferLength * sizeof(WCHAR), lpwExeName);
 257
 258     HeapFree(GetProcessHeap(), 0, lpwSource);
 259     HeapFree(GetProcessHeap(), 0, lpwExeName);
 260
 261     if (dwResult)
 262         dwResult = WideCharToMultiByte(CP_ACP, 0, lpwTargetBuffer, dwResult / sizeof(WCHAR), lpTargetBuffer, TargetBufferLength, NULL, NULL);
 263
 264     HeapFree(GetProcessHeap(), 0, lpwTargetBuffer);
 265
 266     return dwResult;
 267 }
 268
 269
 270 /*
 271  * @implemented
 272  */
 273 DWORD
 274 WINAPI
 275 GetConsoleAliasExesW(LPWSTR lpExeNameBuffer,
 276                      DWORD ExeNameBufferLength)
 277 {
 278     CSR_API_MESSAGE Request;
 279     PCSR_CAPTURE_BUFFER CaptureBuffer;
 280     NTSTATUS Status;
 281
 282     DPRINT("GetConsoleAliasExesW entered\n");
 283
 284     CaptureBuffer = CsrAllocateCaptureBuffer(1, ExeNameBufferLength);
 285     if (!CaptureBuffer)
 286     {
 287         DPRINT1("CsrAllocateCaptureBuffer failed!\n");
 288         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 289         return 0;
 290     }
 291
 292     CsrAllocateMessagePointer(CaptureBuffer,
 293                               ExeNameBufferLength,
 294                               (PVOID*)&Request.Data.GetConsoleAliasesExes.ExeNames);
 295     Request.Data.GetConsoleAliasesExes.Length = ExeNameBufferLength;
 296
 297     Status = CsrClientCallServer(&Request,
 298                                  CaptureBuffer,
 299                                  CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_CONSOLE_ALIASES_EXES),
 300                                  sizeof(CSR_API_MESSAGE));
 301
 302     if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
 303     {
 304         BaseSetLastNTError(Status);
 305         CsrFreeCaptureBuffer(CaptureBuffer);
 306         return 0;
 307     }
 308
 309     memcpy(lpExeNameBuffer,
 310            Request.Data.GetConsoleAliasesExes.ExeNames,
 311            Request.Data.GetConsoleAliasesExes.BytesWritten);
 312
 313     CsrFreeCaptureBuffer(CaptureBuffer);
 314     return Request.Data.GetConsoleAliasesExes.BytesWritten;
 315 }
 316
 317
 318 /*
 319  * @implemented
 320  */
 321 DWORD
 322 WINAPI
 323 GetConsoleAliasExesA(LPSTR lpExeNameBuffer,
 324                      DWORD ExeNameBufferLength)
 325 {
 326     LPWSTR lpwExeNameBuffer;
 327     DWORD dwResult;
 328
 329     DPRINT("GetConsoleAliasExesA entered\n");
 330
 331     lpwExeNameBuffer = HeapAlloc(GetProcessHeap(), 0, ExeNameBufferLength * sizeof(WCHAR));
 332
 333     dwResult = GetConsoleAliasExesW(lpwExeNameBuffer, ExeNameBufferLength * sizeof(WCHAR));
 334
 335     if (dwResult)
 336         dwResult = WideCharToMultiByte(CP_ACP, 0, lpwExeNameBuffer, dwResult / sizeof(WCHAR), lpExeNameBuffer, ExeNameBufferLength, NULL, NULL);
 337
 338     HeapFree(GetProcessHeap(), 0, lpwExeNameBuffer);
 339     return dwResult;
 340 }
 341
 342
 343 /*
 344  * @implemented
 345  */
 346 DWORD
 347 WINAPI
 348 GetConsoleAliasExesLengthW(VOID)
 349 {
 350     CSR_API_MESSAGE Request;
 351     NTSTATUS Status;
 352
 353     DPRINT("GetConsoleAliasExesLengthW entered\n");
 354
 355     Request.Data.GetConsoleAliasesExesLength.Length = 0;
 356
 357     Status = CsrClientCallServer(&Request,
 358                                  NULL,
 359                                  CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_CONSOLE_ALIASES_EXES_LENGTH),
 360                                  sizeof(CSR_API_MESSAGE));
 361
 362     if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
 363     {
 364         BaseSetLastNTError(Status);
 365         return 0;
 366     }
 367
 368     return Request.Data.GetConsoleAliasesExesLength.Length;
 369 }
 370
 371
 372 /*
 373  * @implemented
 374  */
 375 DWORD
 376 WINAPI
 377 GetConsoleAliasExesLengthA(VOID)
 378 {
 379     DWORD dwLength;
 380
 381     DPRINT("GetConsoleAliasExesLengthA entered\n");
 382
 383     dwLength = GetConsoleAliasExesLengthW();
 384
 385     if (dwLength)
 386         dwLength /= sizeof(WCHAR);
 387
 388     return dwLength;
 389 }
 390
 391
 392 /*
 393  * @implemented
 394  */
 395 DWORD
 396 WINAPI
 397 GetConsoleAliasesW(LPWSTR AliasBuffer,
 398                    DWORD AliasBufferLength,
 399                    LPWSTR ExeName)
 400 {
 401     CSR_API_MESSAGE Request;
 402     NTSTATUS Status;
 403     DWORD dwLength;
 404
 405     DPRINT("GetConsoleAliasesW entered\n");
 406
 407     dwLength = GetConsoleAliasesLengthW(ExeName);
 408     if (!dwLength || dwLength > AliasBufferLength)
 409         return 0;
 410
 411     Request.Data.GetAllConsoleAlias.AliasBuffer = AliasBuffer;
 412     Request.Data.GetAllConsoleAlias.AliasBufferLength = AliasBufferLength;
 413     Request.Data.GetAllConsoleAlias.lpExeName = ExeName;
 414
 415     Status = CsrClientCallServer(&Request,
 416                                  NULL,
 417                                  CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_ALL_CONSOLE_ALIASES),
 418                                  sizeof(CSR_API_MESSAGE));
 419
 420     if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
 421     {
 422         BaseSetLastNTError(Status);
 423         return 0;
 424     }
 425
 426     return Request.Data.GetAllConsoleAlias.BytesWritten / sizeof(WCHAR);
 427 }
 428
 429
 430 /*
 431  * @implemented
 432  */
 433 DWORD
 434 WINAPI
 435 GetConsoleAliasesA(LPSTR AliasBuffer,
 436                    DWORD AliasBufferLength,
 437                    LPSTR ExeName)
 438 {
 439     DWORD dwRetVal = 0;
 440     LPWSTR lpwExeName = NULL;
 441     LPWSTR lpwAliasBuffer;
 442
 443     DPRINT("GetConsoleAliasesA entered\n");
 444
 445     if (ExeName)
 446         BasepAnsiStringToHeapUnicodeString(ExeName, (LPWSTR*) &lpwExeName);
 447
 448     lpwAliasBuffer = HeapAlloc(GetProcessHeap(), 0, AliasBufferLength * sizeof(WCHAR));
 449
 450     dwRetVal = GetConsoleAliasesW(lpwAliasBuffer, AliasBufferLength, lpwExeName);
 451
 452     if (lpwExeName)
 453         RtlFreeHeap(GetProcessHeap(), 0, (LPWSTR*) lpwExeName);
 454
 455     if (dwRetVal)
 456         dwRetVal = WideCharToMultiByte(CP_ACP, 0, lpwAliasBuffer, dwRetVal, AliasBuffer, AliasBufferLength, NULL, NULL);
 457
 458     HeapFree(GetProcessHeap(), 0, lpwAliasBuffer);
 459     return dwRetVal;
 460 }
 461
 462
 463 /*
 464  * @implemented
 465  */
 466 DWORD
 467 WINAPI
 468 GetConsoleAliasesLengthW(LPWSTR lpExeName)
 469 {
 470     CSR_API_MESSAGE Request;
 471     NTSTATUS Status;
 472
 473     DPRINT("GetConsoleAliasesLengthW entered\n");
 474
 475     Request.Data.GetAllConsoleAliasesLength.lpExeName = lpExeName;
 476     Request.Data.GetAllConsoleAliasesLength.Length = 0;
 477
 478     Status = CsrClientCallServer(&Request,
 479                                  NULL,
 480                                  CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_ALL_CONSOLE_ALIASES_LENGTH),
 481                                  sizeof(CSR_API_MESSAGE));
 482
 483     if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
 484     {
 485         BaseSetLastNTError(Status);
 486         return 0;
 487     }
 488
 489     return Request.Data.GetAllConsoleAliasesLength.Length;
 490 }
 491
 492
 493 /*
 494  * @implemented
 495  */
 496 DWORD
 497 WINAPI
 498 GetConsoleAliasesLengthA(LPSTR lpExeName)
 499 {
 500     DWORD dwRetVal = 0;
 501     LPWSTR lpExeNameW = NULL;
 502
 503     if (lpExeName)
 504         BasepAnsiStringToHeapUnicodeString(lpExeName, (LPWSTR*) &lpExeNameW);
 505
 506     dwRetVal = GetConsoleAliasesLengthW(lpExeNameW);
 507     if (dwRetVal)
 508         dwRetVal /= sizeof(WCHAR);
 509
 510     /* Clean up */
 511     if (lpExeNameW)
 512         RtlFreeHeap(GetProcessHeap(), 0, (LPWSTR*) lpExeNameW);
 513
 514     return dwRetVal;
 515 }
 516
 517 /* EOF */