reactos/win32ss/printing/base/winspool/printers.c

   1 /*
   2  * PROJECT:     ReactOS Spooler API
   3  * LICENSE:     GNU LGPL v2.1 or any later version as published by the Free Software Foundation
   4  * PURPOSE:     Functions related to Printers and printing
   5  * COPYRIGHT:   Copyright 2015 Colin Finck <colin@reactos.org>
   6  */
   7
   8 #include "precomp.h"
   9
  10 static DWORD
  11 _StartDocPrinterSpooled(PSPOOLER_HANDLE pHandle, PDOC_INFO_1W pDocInfo1, PADDJOB_INFO_1W pAddJobInfo1)
  12 {
  13     DWORD cbNeeded;
  14     DWORD dwErrorCode;
  15     PJOB_INFO_1W pJobInfo1 = NULL;
  16
  17     // Create the spool file.
  18     pHandle->hSPLFile = CreateFileW(pAddJobInfo1->Path, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, 0, NULL);
  19     if (pHandle->hSPLFile == INVALID_HANDLE_VALUE)
  20     {
  21         dwErrorCode = GetLastError();
  22         ERR("CreateFileW failed for \"%S\" with error %lu!\n", pAddJobInfo1->Path, dwErrorCode);
  23         goto Cleanup;
  24     }
  25
  26     // Get the size of the job information.
  27     GetJobW(pHandle->hPrinter, pAddJobInfo1->JobId, 1, NULL, 0, &cbNeeded);
  28     if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
  29     {
  30         dwErrorCode = GetLastError();
  31         ERR("GetJobW failed with error %lu!\n", dwErrorCode);
  32         goto Cleanup;
  33     }
  34
  35     // Allocate enough memory for the returned job information.
  36     pJobInfo1 = HeapAlloc(hProcessHeap, 0, cbNeeded);
  37     if (!pJobInfo1)
  38     {
  39         dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
  40         ERR("HeapAlloc failed with error %lu!\n", GetLastError());
  41         goto Cleanup;
  42     }
  43
  44     // Get the job information.
  45     if (!GetJobW(pHandle->hPrinter, pAddJobInfo1->JobId, 1, (PBYTE)pJobInfo1, cbNeeded, &cbNeeded))
  46     {
  47         dwErrorCode = GetLastError();
  48         ERR("GetJobW failed with error %lu!\n", dwErrorCode);
  49         goto Cleanup;
  50     }
  51
  52     // Add our document information.
  53     pJobInfo1->pDatatype = pDocInfo1->pDatatype;
  54     pJobInfo1->pDocument = pDocInfo1->pDocName;
  55
  56     // Set the new job information.
  57     if (!SetJobW(pHandle->hPrinter, pAddJobInfo1->JobId, 1, (PBYTE)pJobInfo1, 0))
  58     {
  59         dwErrorCode = GetLastError();
  60         ERR("SetJobW failed with error %lu!\n", dwErrorCode);
  61         goto Cleanup;
  62     }
  63
  64     // We were successful!
  65     pHandle->dwJobID = pAddJobInfo1->JobId;
  66     dwErrorCode = ERROR_SUCCESS;
  67
  68 Cleanup:
  69     if (pJobInfo1)
  70         HeapFree(hProcessHeap, 0, pJobInfo1);
  71
  72     return dwErrorCode;
  73 }
  74
  75 static DWORD
  76 _StartDocPrinterWithRPC(PSPOOLER_HANDLE pHandle, PDOC_INFO_1W pDocInfo1)
  77 {
  78     DWORD dwErrorCode;
  79     WINSPOOL_DOC_INFO_CONTAINER DocInfoContainer;
  80
  81     DocInfoContainer.Level = 1;
  82     DocInfoContainer.DocInfo.pDocInfo1 = (WINSPOOL_DOC_INFO_1*)pDocInfo1;
  83
  84     RpcTryExcept
  85     {
  86         dwErrorCode = _RpcStartDocPrinter(pHandle->hPrinter, &DocInfoContainer, &pHandle->dwJobID);
  87     }
  88     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
  89     {
  90         dwErrorCode = RpcExceptionCode();
  91         ERR("_RpcStartDocPrinter failed with exception code %lu!\n", dwErrorCode);
  92     }
  93     RpcEndExcept;
  94
  95     return dwErrorCode;
  96 }
  97
  98 BOOL WINAPI
  99 EnumPrintersA(DWORD Flags, LPSTR Name, DWORD Level, LPBYTE pPrinterEnum, DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned)
 100 {
 101     return FALSE;
 102 }
 103
 104 BOOL WINAPI
 105 EnumPrintersW(DWORD Flags, LPWSTR Name, DWORD Level, LPBYTE pPrinterEnum, DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned)
 106 {
 107     DWORD dwErrorCode;
 108
 109     // Do the RPC call
 110     RpcTryExcept
 111     {
 112         dwErrorCode = _RpcEnumPrinters(Flags, Name, Level, pPrinterEnum, cbBuf, pcbNeeded, pcReturned);
 113     }
 114     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 115     {
 116         dwErrorCode = RpcExceptionCode();
 117         ERR("_RpcEnumPrinters failed with exception code %lu!\n", dwErrorCode);
 118     }
 119     RpcEndExcept;
 120
 121     SetLastError(dwErrorCode);
 122     return (dwErrorCode == ERROR_SUCCESS);
 123 }
 124
 125 BOOL WINAPI
 126 ClosePrinter(HANDLE hPrinter)
 127 {
 128     DWORD dwErrorCode;
 129     PSPOOLER_HANDLE pHandle = (PSPOOLER_HANDLE)hPrinter;
 130
 131     // Sanity checks.
 132     if (!pHandle)
 133     {
 134         dwErrorCode = ERROR_INVALID_HANDLE;
 135         goto Cleanup;
 136     }
 137
 138     // Do the RPC call.
 139     RpcTryExcept
 140     {
 141         dwErrorCode = _RpcClosePrinter(pHandle->hPrinter);
 142     }
 143     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 144     {
 145         dwErrorCode = RpcExceptionCode();
 146         ERR("_RpcClosePrinter failed with exception code %lu!\n", dwErrorCode);
 147     }
 148     RpcEndExcept;
 149
 150     // Close any open file handle.
 151     if (pHandle->hSPLFile != INVALID_HANDLE_VALUE)
 152         CloseHandle(pHandle->hSPLFile);
 153
 154     // Free the memory for the handle.
 155     HeapFree(hProcessHeap, 0, pHandle);
 156
 157 Cleanup:
 158     SetLastError(dwErrorCode);
 159     return (dwErrorCode == ERROR_SUCCESS);
 160
 161 }
 162
 163 DWORD WINAPI
 164 DeviceCapabilitiesA(LPCSTR pDevice, LPCSTR pPort, WORD fwCapability, LPSTR pOutput, const DEVMODEA* pDevMode)
 165 {
 166     return 0;
 167 }
 168
 169 DWORD WINAPI
 170 DeviceCapabilitiesW(LPCWSTR pDevice, LPCWSTR pPort, WORD fwCapability, LPWSTR pOutput, const DEVMODEW* pDevMode)
 171 {
 172     return 0;
 173 }
 174
 175 LONG WINAPI
 176 DocumentPropertiesA(HWND hWnd, HANDLE hPrinter, LPSTR pDeviceName, PDEVMODEA pDevModeOutput, PDEVMODEA pDevModeInput, DWORD fMode)
 177 {
 178     return 0;
 179 }
 180
 181 LONG WINAPI
 182 DocumentPropertiesW(HWND hWnd, HANDLE hPrinter, LPWSTR pDeviceName, PDEVMODEW pDevModeOutput, PDEVMODEW pDevModeInput, DWORD fMode)
 183 {
 184     return 0;
 185 }
 186
 187 BOOL WINAPI
 188 EndDocPrinter(HANDLE hPrinter)
 189 {
 190     DWORD dwErrorCode;
 191     PSPOOLER_HANDLE pHandle = (PSPOOLER_HANDLE)hPrinter;
 192
 193     // Sanity checks.
 194     if (!pHandle)
 195     {
 196         dwErrorCode = ERROR_INVALID_HANDLE;
 197         goto Cleanup;
 198     }
 199
 200     if (pHandle->hSPLFile != INVALID_HANDLE_VALUE)
 201     {
 202         // For spooled jobs, the document is finished by calling _RpcScheduleJob.
 203         RpcTryExcept
 204         {
 205             dwErrorCode = _RpcScheduleJob(pHandle->hPrinter, pHandle->dwJobID);
 206         }
 207         RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 208         {
 209             dwErrorCode = RpcExceptionCode();
 210             ERR("_RpcScheduleJob failed with exception code %lu!\n", dwErrorCode);
 211         }
 212         RpcEndExcept;
 213
 214         // Close the spool file handle.
 215         CloseHandle(pHandle->hSPLFile);
 216     }
 217     else
 218     {
 219         // In all other cases, just call _RpcEndDocPrinter.
 220         RpcTryExcept
 221         {
 222             dwErrorCode = _RpcEndDocPrinter(pHandle->hPrinter);
 223         }
 224         RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 225         {
 226             dwErrorCode = RpcExceptionCode();
 227             ERR("_RpcEndDocPrinter failed with exception code %lu!\n", dwErrorCode);
 228         }
 229         RpcEndExcept;
 230     }
 231
 232     // A new document can now be started again.
 233     pHandle->bStartedDoc = FALSE;
 234
 235 Cleanup:
 236     SetLastError(dwErrorCode);
 237     return (dwErrorCode == ERROR_SUCCESS);
 238 }
 239
 240 BOOL WINAPI
 241 EndPagePrinter(HANDLE hPrinter)
 242 {
 243     DWORD dwErrorCode;
 244     PSPOOLER_HANDLE pHandle = (PSPOOLER_HANDLE)hPrinter;
 245
 246     // Sanity checks.
 247     if (!pHandle)
 248     {
 249         dwErrorCode = ERROR_INVALID_HANDLE;
 250         goto Cleanup;
 251     }
 252
 253     if (pHandle->hSPLFile != INVALID_HANDLE_VALUE)
 254     {
 255         // For spooled jobs, we don't need to do anything.
 256         dwErrorCode = ERROR_SUCCESS;
 257     }
 258     else
 259     {
 260         // In all other cases, just call _RpcEndPagePrinter.
 261         RpcTryExcept
 262         {
 263             dwErrorCode = _RpcEndPagePrinter(pHandle->hPrinter);
 264         }
 265         RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 266         {
 267             dwErrorCode = RpcExceptionCode();
 268             ERR("_RpcEndPagePrinter failed with exception code %lu!\n", dwErrorCode);
 269         }
 270         RpcEndExcept;
 271     }
 272
 273 Cleanup:
 274     SetLastError(dwErrorCode);
 275     return (dwErrorCode == ERROR_SUCCESS);
 276 }
 277
 278 BOOL WINAPI
 279 GetDefaultPrinterA(LPSTR pszBuffer, LPDWORD pcchBuffer)
 280 {
 281     return FALSE;
 282 }
 283
 284 BOOL WINAPI
 285 GetDefaultPrinterW(LPWSTR pszBuffer, LPDWORD pcchBuffer)
 286 {
 287     return FALSE;
 288 }
 289
 290 BOOL WINAPI
 291 GetPrinterA(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter, DWORD cbBuf, LPDWORD pcbNeeded)
 292 {
 293     return FALSE;
 294 }
 295
 296 BOOL WINAPI
 297 GetPrinterDriverA(HANDLE hPrinter, LPSTR pEnvironment, DWORD Level, LPBYTE pDriverInfo, DWORD cbBuf, LPDWORD pcbNeeded)
 298 {
 299     return FALSE;
 300 }
 301
 302 BOOL WINAPI
 303 GetPrinterDriverW(HANDLE hPrinter, LPWSTR pEnvironment, DWORD Level, LPBYTE pDriverInfo, DWORD cbBuf, LPDWORD pcbNeeded)
 304 {
 305     return FALSE;
 306 }
 307
 308 BOOL WINAPI
 309 GetPrinterW(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter, DWORD cbBuf, LPDWORD pcbNeeded)
 310 {
 311     return FALSE;
 312 }
 313
 314 BOOL WINAPI
 315 OpenPrinterA(LPSTR pPrinterName, LPHANDLE phPrinter, LPPRINTER_DEFAULTSA pDefault)
 316 {
 317     BOOL bReturnValue = FALSE;
 318     PWSTR pwszPrinterName = NULL;
 319     PWSTR pwszDatatype = NULL;
 320     PRINTER_DEFAULTSW wDefault = { 0 };
 321     size_t StringLength;
 322
 323     if (pPrinterName)
 324     {
 325         // Convert pPrinterName to a Unicode string pwszPrinterName
 326         StringLength = strlen(pPrinterName) + 1;
 327
 328         pwszPrinterName = HeapAlloc(hProcessHeap, 0, StringLength * sizeof(WCHAR));
 329         if (!pwszPrinterName)
 330         {
 331             ERR("HeapAlloc failed for pwszPrinterName with last error %lu!\n", GetLastError());
 332             goto Cleanup;
 333         }
 334
 335         MultiByteToWideChar(CP_ACP, 0, pPrinterName, -1, pwszPrinterName, StringLength);
 336     }
 337
 338     if (pDefault)
 339     {
 340         wDefault.DesiredAccess = pDefault->DesiredAccess;
 341
 342         if (pDefault->pDatatype)
 343         {
 344             // Convert pDefault->pDatatype to a Unicode string pwszDatatype that later becomes wDefault.pDatatype
 345             StringLength = strlen(pDefault->pDatatype) + 1;
 346
 347             pwszDatatype = HeapAlloc(hProcessHeap, 0, StringLength * sizeof(WCHAR));
 348             if (!pwszDatatype)
 349             {
 350                 ERR("HeapAlloc failed for pwszDatatype with last error %lu!\n", GetLastError());
 351                 goto Cleanup;
 352             }
 353
 354             MultiByteToWideChar(CP_ACP, 0, pDefault->pDatatype, -1, pwszDatatype, StringLength);
 355             wDefault.pDatatype = pwszDatatype;
 356         }
 357
 358         if (pDefault->pDevMode)
 359             wDefault.pDevMode = GdiConvertToDevmodeW(pDefault->pDevMode);
 360     }
 361
 362     bReturnValue = OpenPrinterW(pwszPrinterName, phPrinter, &wDefault);
 363
 364 Cleanup:
 365     if (wDefault.pDevMode)
 366         HeapFree(hProcessHeap, 0, wDefault.pDevMode);
 367
 368     if (pwszPrinterName)
 369         HeapFree(hProcessHeap, 0, pwszPrinterName);
 370
 371     if (pwszDatatype)
 372         HeapFree(hProcessHeap, 0, pwszDatatype);
 373
 374     return bReturnValue;
 375 }
 376
 377 BOOL WINAPI
 378 OpenPrinterW(LPWSTR pPrinterName, LPHANDLE phPrinter, LPPRINTER_DEFAULTSW pDefault)
 379 {
 380     DWORD dwErrorCode;
 381     HANDLE hPrinter;
 382     PSPOOLER_HANDLE pHandle;
 383     PWSTR pDatatype = NULL;
 384     WINSPOOL_DEVMODE_CONTAINER DevModeContainer;
 385     WINSPOOL_DEVMODE_CONTAINER* pDevModeContainer = NULL;
 386     ACCESS_MASK AccessRequired = 0;
 387
 388     // Prepare the additional parameters in the format required by _RpcOpenPrinter
 389     if (pDefault)
 390     {
 391         pDatatype = pDefault->pDatatype;
 392         DevModeContainer.cbBuf = sizeof(DEVMODEW);
 393         DevModeContainer.pDevMode = (BYTE*)pDefault->pDevMode;
 394         pDevModeContainer = &DevModeContainer;
 395         AccessRequired = pDefault->DesiredAccess;
 396     }
 397
 398     // Do the RPC call
 399     RpcTryExcept
 400     {
 401         dwErrorCode = _RpcOpenPrinter(pPrinterName, &hPrinter, pDatatype, pDevModeContainer, AccessRequired);
 402     }
 403     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 404     {
 405         dwErrorCode = RpcExceptionCode();
 406         ERR("_RpcOpenPrinter failed with exception code %lu!\n", dwErrorCode);
 407     }
 408     RpcEndExcept;
 409
 410     if (dwErrorCode == ERROR_SUCCESS)
 411     {
 412         // Create a new SPOOLER_HANDLE structure.
 413         pHandle = HeapAlloc(hProcessHeap, HEAP_ZERO_MEMORY, sizeof(SPOOLER_HANDLE));
 414         if (!pHandle)
 415         {
 416             dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
 417             ERR("HeapAlloc failed with error %lu!\n", GetLastError());
 418             goto Cleanup;
 419         }
 420
 421         pHandle->hPrinter = hPrinter;
 422         pHandle->hSPLFile = INVALID_HANDLE_VALUE;
 423
 424         // Return it as phPrinter.
 425         *phPrinter = (HANDLE)pHandle;
 426     }
 427
 428 Cleanup:
 429     SetLastError(dwErrorCode);
 430     return (dwErrorCode == ERROR_SUCCESS);
 431 }
 432
 433 BOOL WINAPI
 434 ReadPrinter(HANDLE hPrinter, PVOID pBuf, DWORD cbBuf, PDWORD pNoBytesRead)
 435 {
 436     DWORD dwErrorCode;
 437     PSPOOLER_HANDLE pHandle = (PSPOOLER_HANDLE)hPrinter;
 438
 439     // Sanity checks.
 440     if (!pHandle)
 441     {
 442         dwErrorCode = ERROR_INVALID_HANDLE;
 443         goto Cleanup;
 444     }
 445
 446     // Do the RPC call
 447     RpcTryExcept
 448     {
 449         dwErrorCode = _RpcReadPrinter(pHandle->hPrinter, pBuf, cbBuf, pNoBytesRead);
 450     }
 451     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 452     {
 453         dwErrorCode = RpcExceptionCode();
 454         ERR("_RpcReadPrinter failed with exception code %lu!\n", dwErrorCode);
 455     }
 456     RpcEndExcept;
 457
 458 Cleanup:
 459     SetLastError(dwErrorCode);
 460     return (dwErrorCode == ERROR_SUCCESS);
 461 }
 462
 463 DWORD WINAPI
 464 StartDocPrinterW(HANDLE hPrinter, DWORD Level, PBYTE pDocInfo)
 465 {
 466     DWORD cbAddJobInfo1;
 467     DWORD cbNeeded;
 468     DWORD dwErrorCode;
 469     PADDJOB_INFO_1W pAddJobInfo1 = NULL;
 470     PDOC_INFO_1W pDocInfo1 = (PDOC_INFO_1W)pDocInfo;
 471     PSPOOLER_HANDLE pHandle = (PSPOOLER_HANDLE)hPrinter;
 472
 473     // Sanity checks.
 474     if (!pHandle)
 475     {
 476         dwErrorCode = ERROR_INVALID_HANDLE;
 477         goto Cleanup;
 478     }
 479
 480     if (!pDocInfo1)
 481     {
 482         dwErrorCode = ERROR_INVALID_PARAMETER;
 483         goto Cleanup;
 484     }
 485
 486     if (Level != 1)
 487     {
 488         dwErrorCode = ERROR_INVALID_LEVEL;
 489         goto Cleanup;
 490     }
 491
 492     if (pHandle->bStartedDoc)
 493     {
 494         dwErrorCode = ERROR_INVALID_PRINTER_STATE;
 495         goto Cleanup;
 496     }
 497
 498     // Check if we want to redirect output into a file.
 499     if (pDocInfo1->pOutputFile)
 500     {
 501         // Do a StartDocPrinter RPC call in this case.
 502         dwErrorCode = _StartDocPrinterWithRPC(pHandle, pDocInfo1);
 503     }
 504     else
 505     {
 506         // Allocate memory for the ADDJOB_INFO_1W structure and a path.
 507         cbAddJobInfo1 = sizeof(ADDJOB_INFO_1W) + MAX_PATH * sizeof(WCHAR);
 508         pAddJobInfo1 = HeapAlloc(hProcessHeap, 0, cbAddJobInfo1);
 509         if (!pAddJobInfo1)
 510         {
 511             dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
 512             ERR("HeapAlloc failed with error %lu!\n", GetLastError());
 513             goto Cleanup;
 514         }
 515
 516         // Try to add a new job.
 517         // This only succeeds if the printer is set to do spooled printing.
 518         if (AddJobW(pHandle->hPrinter, 1, (PBYTE)pAddJobInfo1, cbAddJobInfo1, &cbNeeded))
 519         {
 520             // Do spooled printing.
 521             dwErrorCode = _StartDocPrinterSpooled(pHandle, pDocInfo1, pAddJobInfo1);
 522         }
 523         else if (GetLastError() == ERROR_INVALID_ACCESS)
 524         {
 525             // ERROR_INVALID_ACCESS is returned when the printer is set to do direct printing.
 526             // In this case, we do a StartDocPrinter RPC call.
 527             dwErrorCode = _StartDocPrinterWithRPC(pHandle, pDocInfo1);
 528         }
 529         else
 530         {
 531             dwErrorCode = GetLastError();
 532             ERR("AddJobW failed with error %lu!\n", dwErrorCode);
 533             goto Cleanup;
 534         }
 535     }
 536
 537     if (dwErrorCode == ERROR_SUCCESS)
 538         pHandle->bStartedDoc = TRUE;
 539
 540 Cleanup:
 541     if (pAddJobInfo1)
 542         HeapFree(hProcessHeap, 0, pAddJobInfo1);
 543
 544     SetLastError(dwErrorCode);
 545     return pHandle->dwJobID;
 546 }
 547
 548 BOOL WINAPI
 549 StartPagePrinter(HANDLE hPrinter)
 550 {
 551     DWORD dwErrorCode;
 552     PSPOOLER_HANDLE pHandle = (PSPOOLER_HANDLE)hPrinter;
 553
 554     // Sanity checks.
 555     if (!pHandle)
 556     {
 557         dwErrorCode = ERROR_INVALID_HANDLE;
 558         goto Cleanup;
 559     }
 560
 561     // Do the RPC call
 562     RpcTryExcept
 563     {
 564         dwErrorCode = _RpcStartPagePrinter(pHandle->hPrinter);
 565     }
 566     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 567     {
 568         dwErrorCode = RpcExceptionCode();
 569         ERR("_RpcStartPagePrinter failed with exception code %lu!\n", dwErrorCode);
 570     }
 571     RpcEndExcept;
 572
 573 Cleanup:
 574     SetLastError(dwErrorCode);
 575     return (dwErrorCode == ERROR_SUCCESS);
 576 }
 577
 578 BOOL WINAPI
 579 WritePrinter(HANDLE hPrinter, PVOID pBuf, DWORD cbBuf, PDWORD pcWritten)
 580 {
 581     DWORD dwErrorCode;
 582     PSPOOLER_HANDLE pHandle = (PSPOOLER_HANDLE)hPrinter;
 583
 584     // Sanity checks.
 585     if (!pHandle)
 586     {
 587         dwErrorCode = ERROR_INVALID_HANDLE;
 588         goto Cleanup;
 589     }
 590
 591     if (!pHandle->bStartedDoc)
 592     {
 593         dwErrorCode = ERROR_SPL_NO_STARTDOC;
 594         goto Cleanup;
 595     }
 596
 597     if (pHandle->hSPLFile != INVALID_HANDLE_VALUE)
 598     {
 599         // Write to the spool file. This doesn't need an RPC request.
 600         if (!WriteFile(pHandle->hSPLFile, pBuf, cbBuf, pcWritten, NULL))
 601         {
 602             dwErrorCode = GetLastError();
 603             ERR("WriteFile failed with error %lu!\n", dwErrorCode);
 604             goto Cleanup;
 605         }
 606
 607         dwErrorCode = ERROR_SUCCESS;
 608     }
 609     else
 610     {
 611         // TODO: This case (for direct printing or remote printing) has bad performance if multiple small-sized WritePrinter calls are performed.
 612         // We may increase performance by writing into a buffer and only doing a single RPC call when the buffer is full.
 613
 614         // Do the RPC call
 615         RpcTryExcept
 616         {
 617             dwErrorCode = _RpcWritePrinter(pHandle->hPrinter, pBuf, cbBuf, pcWritten);
 618         }
 619         RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 620         {
 621             dwErrorCode = RpcExceptionCode();
 622             ERR("_RpcWritePrinter failed with exception code %lu!\n", dwErrorCode);
 623         }
 624         RpcEndExcept;
 625     }
 626
 627 Cleanup:
 628     SetLastError(dwErrorCode);
 629     return (dwErrorCode == ERROR_SUCCESS);
 630 }
 631
 632 BOOL WINAPI
 633 XcvDataW(HANDLE hXcv, PCWSTR pszDataName, PBYTE pInputData, DWORD cbInputData, PBYTE pOutputData, DWORD cbOutputData, PDWORD pcbOutputNeeded, PDWORD pdwStatus)
 634 {
 635     return FALSE;
 636 }