src/printing/backend/win_helper.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "printing/backend/win_helper.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/file_version_info.h"
  10 #include "base/files/file_path.h"
  11 #include "base/logging.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/numerics/safe_conversions.h"
  14 #include "base/strings/string_util.h"
  15 #include "base/strings/stringprintf.h"
  16 #include "base/strings/utf_string_conversions.h"
  17 #include "base/win/scoped_comptr.h"
  18 #include "printing/backend/print_backend.h"
  19 #include "printing/backend/print_backend_consts.h"
  20 #include "printing/backend/printing_info_win.h"
  21
  22 namespace {
  23
  24 typedef HRESULT (WINAPI* PTOpenProviderProc)(PCWSTR printer_name,
  25                                              DWORD version,
  26                                              HPTPROVIDER* provider);
  27
  28 typedef HRESULT (WINAPI* PTGetPrintCapabilitiesProc)(HPTPROVIDER provider,
  29                                                      IStream* print_ticket,
  30                                                      IStream* capabilities,
  31                                                      BSTR* error_message);
  32
  33 typedef HRESULT (WINAPI* PTConvertDevModeToPrintTicketProc)(
  34     HPTPROVIDER provider,
  35     ULONG devmode_size_in_bytes,
  36     PDEVMODE devmode,
  37     EPrintTicketScope scope,
  38     IStream* print_ticket);
  39
  40 typedef HRESULT (WINAPI* PTConvertPrintTicketToDevModeProc)(
  41     HPTPROVIDER provider,
  42     IStream* print_ticket,
  43     EDefaultDevmodeType base_devmode_type,
  44     EPrintTicketScope scope,
  45     ULONG* devmode_byte_count,
  46     PDEVMODE* devmode,
  47     BSTR* error_message);
  48
  49 typedef HRESULT (WINAPI* PTMergeAndValidatePrintTicketProc)(
  50     HPTPROVIDER provider,
  51     IStream* base_ticket,
  52     IStream* delta_ticket,
  53     EPrintTicketScope scope,
  54     IStream* result_ticket,
  55     BSTR* error_message);
  56
  57 typedef HRESULT (WINAPI* PTReleaseMemoryProc)(PVOID buffer);
  58
  59 typedef HRESULT (WINAPI* PTCloseProviderProc)(HPTPROVIDER provider);
  60
  61 typedef HRESULT (WINAPI* StartXpsPrintJobProc)(
  62     const LPCWSTR printer_name,
  63     const LPCWSTR job_name,
  64     const LPCWSTR output_file_name,
  65     HANDLE progress_event,
  66     HANDLE completion_event,
  67     UINT8* printable_pages_on,
  68     UINT32 printable_pages_on_count,
  69     IXpsPrintJob** xps_print_job,
  70     IXpsPrintJobStream** document_stream,
  71     IXpsPrintJobStream** print_ticket_stream);
  72
  73 PTOpenProviderProc g_open_provider_proc = NULL;
  74 PTGetPrintCapabilitiesProc g_get_print_capabilities_proc = NULL;
  75 PTConvertDevModeToPrintTicketProc g_convert_devmode_to_print_ticket_proc = NULL;
  76 PTConvertPrintTicketToDevModeProc g_convert_print_ticket_to_devmode_proc = NULL;
  77 PTMergeAndValidatePrintTicketProc g_merge_and_validate_print_ticket_proc = NULL;
  78 PTReleaseMemoryProc g_release_memory_proc = NULL;
  79 PTCloseProviderProc g_close_provider_proc = NULL;
  80 StartXpsPrintJobProc g_start_xps_print_job_proc = NULL;
  81
  82 HRESULT StreamFromPrintTicket(const std::string& print_ticket,
  83                               IStream** stream) {
  84   DCHECK(stream);
  85   HRESULT hr = CreateStreamOnHGlobal(NULL, TRUE, stream);
  86   if (FAILED(hr)) {
  87     return hr;
  88   }
  89   ULONG bytes_written = 0;
  90   (*stream)->Write(print_ticket.c_str(),
  91                    base::checked_cast<ULONG>(print_ticket.length()),
  92                    &bytes_written);
  93   DCHECK(bytes_written == print_ticket.length());
  94   LARGE_INTEGER pos = {0};
  95   ULARGE_INTEGER new_pos = {0};
  96   (*stream)->Seek(pos, STREAM_SEEK_SET, &new_pos);
  97   return S_OK;
  98 }
  99
 100 const char kXpsTicketTemplate[] =
 101   "<?xml version='1.0' encoding='UTF-8'?>"
 102   "<psf:PrintTicket "
 103   "xmlns:psf='"
 104   "http://schemas.microsoft.com/windows/2003/08/printing/printschemaframework' "
 105   "xmlns:psk="
 106   "'http://schemas.microsoft.com/windows/2003/08/printing/printschemakeywords' "
 107   "version='1'>"
 108   "<psf:Feature name='psk:PageOutputColor'>"
 109   "<psf:Option name='psk:%s'>"
 110   "</psf:Option>"
 111   "</psf:Feature>"
 112   "</psf:PrintTicket>";
 113
 114 const char kXpsTicketColor[] = "Color";
 115 const char kXpsTicketMonochrome[] = "Monochrome";
 116
 117
 118 }  // namespace
 119
 120
 121 namespace printing {
 122
 123 bool XPSModule::Init() {
 124   static bool initialized = InitImpl();
 125   return initialized;
 126 }
 127
 128 bool XPSModule::InitImpl() {
 129   HMODULE prntvpt_module = LoadLibrary(L"prntvpt.dll");
 130   if (prntvpt_module == NULL)
 131     return false;
 132   g_open_provider_proc = reinterpret_cast<PTOpenProviderProc>(
 133       GetProcAddress(prntvpt_module, "PTOpenProvider"));
 134   if (!g_open_provider_proc) {
 135     NOTREACHED();
 136     return false;
 137   }
 138   g_get_print_capabilities_proc = reinterpret_cast<PTGetPrintCapabilitiesProc>(
 139       GetProcAddress(prntvpt_module, "PTGetPrintCapabilities"));
 140   if (!g_get_print_capabilities_proc) {
 141     NOTREACHED();
 142     return false;
 143   }
 144   g_convert_devmode_to_print_ticket_proc =
 145       reinterpret_cast<PTConvertDevModeToPrintTicketProc>(
 146           GetProcAddress(prntvpt_module, "PTConvertDevModeToPrintTicket"));
 147   if (!g_convert_devmode_to_print_ticket_proc) {
 148     NOTREACHED();
 149     return false;
 150   }
 151   g_convert_print_ticket_to_devmode_proc =
 152       reinterpret_cast<PTConvertPrintTicketToDevModeProc>(
 153           GetProcAddress(prntvpt_module, "PTConvertPrintTicketToDevMode"));
 154   if (!g_convert_print_ticket_to_devmode_proc) {
 155     NOTREACHED();
 156     return false;
 157   }
 158   g_merge_and_validate_print_ticket_proc =
 159       reinterpret_cast<PTMergeAndValidatePrintTicketProc>(
 160           GetProcAddress(prntvpt_module, "PTMergeAndValidatePrintTicket"));
 161   if (!g_merge_and_validate_print_ticket_proc) {
 162     NOTREACHED();
 163     return false;
 164   }
 165   g_release_memory_proc =
 166       reinterpret_cast<PTReleaseMemoryProc>(
 167           GetProcAddress(prntvpt_module, "PTReleaseMemory"));
 168   if (!g_release_memory_proc) {
 169     NOTREACHED();
 170     return false;
 171   }
 172   g_close_provider_proc =
 173       reinterpret_cast<PTCloseProviderProc>(
 174           GetProcAddress(prntvpt_module, "PTCloseProvider"));
 175   if (!g_close_provider_proc) {
 176     NOTREACHED();
 177     return false;
 178   }
 179   return true;
 180 }
 181
 182 HRESULT XPSModule::OpenProvider(const base::string16& printer_name,
 183                                 DWORD version,
 184                                 HPTPROVIDER* provider) {
 185   return g_open_provider_proc(printer_name.c_str(), version, provider);
 186 }
 187
 188 HRESULT XPSModule::GetPrintCapabilities(HPTPROVIDER provider,
 189                                         IStream* print_ticket,
 190                                         IStream* capabilities,
 191                                         BSTR* error_message) {
 192   return g_get_print_capabilities_proc(provider,
 193                                        print_ticket,
 194                                        capabilities,
 195                                        error_message);
 196 }
 197
 198 HRESULT XPSModule::ConvertDevModeToPrintTicket(HPTPROVIDER provider,
 199                                                ULONG devmode_size_in_bytes,
 200                                                PDEVMODE devmode,
 201                                                EPrintTicketScope scope,
 202                                                IStream* print_ticket) {
 203   return g_convert_devmode_to_print_ticket_proc(provider,
 204                                                 devmode_size_in_bytes,
 205                                                 devmode,
 206                                                 scope,
 207                                                 print_ticket);
 208 }
 209
 210 HRESULT XPSModule::ConvertPrintTicketToDevMode(
 211     HPTPROVIDER provider,
 212     IStream* print_ticket,
 213     EDefaultDevmodeType base_devmode_type,
 214     EPrintTicketScope scope,
 215     ULONG* devmode_byte_count,
 216     PDEVMODE* devmode,
 217     BSTR* error_message) {
 218   return g_convert_print_ticket_to_devmode_proc(provider,
 219                                                 print_ticket,
 220                                                 base_devmode_type,
 221                                                 scope,
 222                                                 devmode_byte_count,
 223                                                 devmode,
 224                                                 error_message);
 225 }
 226
 227 HRESULT XPSModule::MergeAndValidatePrintTicket(HPTPROVIDER provider,
 228                                                IStream* base_ticket,
 229                                                IStream* delta_ticket,
 230                                                EPrintTicketScope scope,
 231                                                IStream* result_ticket,
 232                                                BSTR* error_message) {
 233   return g_merge_and_validate_print_ticket_proc(provider,
 234                                                 base_ticket,
 235                                                 delta_ticket,
 236                                                 scope,
 237                                                 result_ticket,
 238                                                 error_message);
 239 }
 240
 241 HRESULT XPSModule::ReleaseMemory(PVOID buffer) {
 242   return g_release_memory_proc(buffer);
 243 }
 244
 245 HRESULT XPSModule::CloseProvider(HPTPROVIDER provider) {
 246   return g_close_provider_proc(provider);
 247 }
 248
 249 ScopedXPSInitializer::ScopedXPSInitializer() : initialized_(false) {
 250   if (!XPSModule::Init())
 251     return;
 252   // Calls to XPS APIs typically require the XPS provider to be opened with
 253   // PTOpenProvider. PTOpenProvider calls CoInitializeEx with
 254   // COINIT_MULTITHREADED. We have seen certain buggy HP printer driver DLLs
 255   // that call CoInitializeEx with COINIT_APARTMENTTHREADED in the context of
 256   // PTGetPrintCapabilities. This call fails but the printer driver calls
 257   // CoUninitialize anyway. This results in the apartment being torn down too
 258   // early and the msxml DLL being unloaded which in turn causes code in
 259   // unidrvui.dll to have a dangling pointer to an XML document which causes a
 260   // crash. To protect ourselves from such drivers we make sure we always have
 261   // an extra CoInitialize (calls to CoInitialize/CoUninitialize are
 262   // refcounted).
 263   HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
 264   // If this succeeded we are done because the PTOpenProvider call will provide
 265   // the extra refcount on the apartment. If it failed because someone already
 266   // called CoInitializeEx with COINIT_APARTMENTTHREADED, we try the other model
 267   // to provide the additional refcount (since we don't know which model buggy
 268   // printer drivers will use).
 269   if (!SUCCEEDED(hr))
 270     hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 271   DCHECK(SUCCEEDED(hr));
 272   initialized_ = true;
 273 }
 274
 275 ScopedXPSInitializer::~ScopedXPSInitializer() {
 276   if (initialized_)
 277     CoUninitialize();
 278   initialized_ = false;
 279 }
 280
 281 bool XPSPrintModule::Init() {
 282   static bool initialized = InitImpl();
 283   return initialized;
 284 }
 285
 286 bool XPSPrintModule::InitImpl() {
 287   HMODULE xpsprint_module = LoadLibrary(L"xpsprint.dll");
 288   if (xpsprint_module == NULL)
 289     return false;
 290   g_start_xps_print_job_proc = reinterpret_cast<StartXpsPrintJobProc>(
 291       GetProcAddress(xpsprint_module, "StartXpsPrintJob"));
 292   if (!g_start_xps_print_job_proc) {
 293     NOTREACHED();
 294     return false;
 295   }
 296   return true;
 297 }
 298
 299 HRESULT XPSPrintModule::StartXpsPrintJob(
 300     const LPCWSTR printer_name,
 301     const LPCWSTR job_name,
 302     const LPCWSTR output_file_name,
 303     HANDLE progress_event,
 304     HANDLE completion_event,
 305     UINT8* printable_pages_on,
 306     UINT32 printable_pages_on_count,
 307     IXpsPrintJob** xps_print_job,
 308     IXpsPrintJobStream** document_stream,
 309     IXpsPrintJobStream** print_ticket_stream) {
 310   return g_start_xps_print_job_proc(printer_name,
 311                                     job_name,
 312                                     output_file_name,
 313                                     progress_event,
 314                                     completion_event,
 315                                     printable_pages_on,
 316                                     printable_pages_on_count,
 317                                     xps_print_job,
 318                                     document_stream,
 319                                     print_ticket_stream);
 320 }
 321
 322 bool InitBasicPrinterInfo(HANDLE printer, PrinterBasicInfo* printer_info) {
 323   DCHECK(printer);
 324   DCHECK(printer_info);
 325   if (!printer)
 326     return false;
 327
 328   PrinterInfo2 info_2;
 329   if (!info_2.Init(printer))
 330     return false;
 331
 332   printer_info->printer_name = base::WideToUTF8(info_2.get()->pPrinterName);
 333   if (info_2.get()->pComment) {
 334     printer_info->printer_description =
 335         base::WideToUTF8(info_2.get()->pComment);
 336   }
 337   if (info_2.get()->pLocation) {
 338     printer_info->options[kLocationTagName] =
 339         base::WideToUTF8(info_2.get()->pLocation);
 340   }
 341   if (info_2.get()->pDriverName) {
 342     printer_info->options[kDriverNameTagName] =
 343         base::WideToUTF8(info_2.get()->pDriverName);
 344   }
 345   printer_info->printer_status = info_2.get()->Status;
 346
 347   std::string driver_info = GetDriverInfo(printer);
 348   if (!driver_info.empty())
 349     printer_info->options[kDriverInfoTagName] = driver_info;
 350   return true;
 351 }
 352
 353 std::string GetDriverInfo(HANDLE printer) {
 354   DCHECK(printer);
 355   std::string driver_info;
 356
 357   if (!printer)
 358     return driver_info;
 359
 360   DriverInfo6 info_6;
 361   if (!info_6.Init(printer))
 362     return driver_info;
 363
 364   std::string info[4];
 365   if (info_6.get()->pName)
 366     info[0] = base::WideToUTF8(info_6.get()->pName);
 367
 368   if (info_6.get()->pDriverPath) {
 369     scoped_ptr<FileVersionInfo> version_info(
 370         FileVersionInfo::CreateFileVersionInfo(
 371             base::FilePath(info_6.get()->pDriverPath)));
 372     if (version_info.get()) {
 373       info[1] = base::WideToUTF8(version_info->file_version());
 374       info[2] = base::WideToUTF8(version_info->product_name());
 375       info[3] = base::WideToUTF8(version_info->product_version());
 376     }
 377   }
 378
 379   for (size_t i = 0; i < arraysize(info); ++i) {
 380     std::replace(info[i].begin(), info[i].end(), ';', ',');
 381     driver_info.append(info[i]);
 382     if (i < arraysize(info) - 1)
 383       driver_info.append(";");
 384   }
 385   return driver_info;
 386 }
 387
 388 scoped_ptr<DEVMODE, base::FreeDeleter> XpsTicketToDevMode(
 389     const base::string16& printer_name,
 390     const std::string& print_ticket) {
 391   scoped_ptr<DEVMODE, base::FreeDeleter> dev_mode;
 392   printing::ScopedXPSInitializer xps_initializer;
 393   if (!xps_initializer.initialized()) {
 394     // TODO(sanjeevr): Handle legacy proxy case (with no prntvpt.dll)
 395     return dev_mode.Pass();
 396   }
 397
 398   printing::ScopedPrinterHandle printer;
 399   if (!printer.OpenPrinter(printer_name.c_str()))
 400     return dev_mode.Pass();
 401
 402   base::win::ScopedComPtr<IStream> pt_stream;
 403   HRESULT hr = StreamFromPrintTicket(print_ticket, pt_stream.Receive());
 404   if (FAILED(hr))
 405     return dev_mode.Pass();
 406
 407   HPTPROVIDER provider = NULL;
 408   hr = printing::XPSModule::OpenProvider(printer_name, 1, &provider);
 409   if (SUCCEEDED(hr)) {
 410     ULONG size = 0;
 411     DEVMODE* dm = NULL;
 412     // Use kPTJobScope, because kPTDocumentScope breaks duplex.
 413     hr = printing::XPSModule::ConvertPrintTicketToDevMode(provider,
 414                                                           pt_stream,
 415                                                           kUserDefaultDevmode,
 416                                                           kPTJobScope,
 417                                                           &size,
 418                                                           &dm,
 419                                                           NULL);
 420     if (SUCCEEDED(hr)) {
 421       // Correct DEVMODE using DocumentProperties. See documentation for
 422       // PTConvertPrintTicketToDevMode.
 423       dev_mode = CreateDevMode(printer.Get(), dm);
 424       printing::XPSModule::ReleaseMemory(dm);
 425     }
 426     printing::XPSModule::CloseProvider(provider);
 427   }
 428   return dev_mode.Pass();
 429 }
 430
 431 scoped_ptr<DEVMODE, base::FreeDeleter> CreateDevModeWithColor(
 432     HANDLE printer,
 433     const base::string16& printer_name,
 434     bool color) {
 435   scoped_ptr<DEVMODE, base::FreeDeleter> default_ticket =
 436       CreateDevMode(printer, NULL);
 437   if (!default_ticket)
 438     return default_ticket.Pass();
 439
 440   if ((default_ticket->dmFields & DM_COLOR) &&
 441       ((default_ticket->dmColor == DMCOLOR_COLOR) == color)) {
 442     return default_ticket.Pass();
 443   }
 444
 445   default_ticket->dmFields |= DM_COLOR;
 446   default_ticket->dmColor = color ? DMCOLOR_COLOR : DMCOLOR_MONOCHROME;
 447
 448   DriverInfo6 info_6;
 449   if (!info_6.Init(printer))
 450     return default_ticket.Pass();
 451
 452   const DRIVER_INFO_6* p = info_6.get();
 453
 454   // Only HP known to have issues.
 455   if (!p->pszMfgName || wcscmp(p->pszMfgName, L"HP") != 0)
 456     return default_ticket.Pass();
 457
 458   // Need XPS for this workaround.
 459   printing::ScopedXPSInitializer xps_initializer;
 460   if (!xps_initializer.initialized())
 461     return default_ticket.Pass();
 462
 463   const char* xps_color = color ? kXpsTicketColor : kXpsTicketMonochrome;
 464   std::string xps_ticket = base::StringPrintf(kXpsTicketTemplate, xps_color);
 465   scoped_ptr<DEVMODE, base::FreeDeleter> ticket =
 466       printing::XpsTicketToDevMode(printer_name, xps_ticket);
 467   if (!ticket)
 468     return default_ticket.Pass();
 469
 470   return ticket.Pass();
 471 }
 472
 473 scoped_ptr<DEVMODE, base::FreeDeleter> CreateDevMode(HANDLE printer,
 474                                                      DEVMODE* in) {
 475   LONG buffer_size = DocumentProperties(
 476       NULL, printer, const_cast<wchar_t*>(L""), NULL, NULL, 0);
 477   if (buffer_size < static_cast<int>(sizeof(DEVMODE)))
 478     return scoped_ptr<DEVMODE, base::FreeDeleter>();
 479   scoped_ptr<DEVMODE, base::FreeDeleter> out(
 480       reinterpret_cast<DEVMODE*>(calloc(buffer_size, 1)));
 481   DWORD flags = (in ? (DM_IN_BUFFER) : 0) | DM_OUT_BUFFER;
 482   if (DocumentProperties(
 483           NULL, printer, const_cast<wchar_t*>(L""), out.get(), in, flags) !=
 484       IDOK) {
 485     return scoped_ptr<DEVMODE, base::FreeDeleter>();
 486   }
 487   int size = out->dmSize;
 488   int extra_size = out->dmDriverExtra;
 489   CHECK_GE(buffer_size, size + extra_size);
 490   return out.Pass();
 491 }
 492
 493 scoped_ptr<DEVMODE, base::FreeDeleter> PromptDevMode(
 494     HANDLE printer,
 495     const base::string16& printer_name,
 496     DEVMODE* in,
 497     HWND window,
 498     bool* canceled) {
 499   LONG buffer_size =
 500       DocumentProperties(window,
 501                          printer,
 502                          const_cast<wchar_t*>(printer_name.c_str()),
 503                          NULL,
 504                          NULL,
 505                          0);
 506   if (buffer_size < static_cast<int>(sizeof(DEVMODE)))
 507     return scoped_ptr<DEVMODE, base::FreeDeleter>();
 508   scoped_ptr<DEVMODE, base::FreeDeleter> out(
 509       reinterpret_cast<DEVMODE*>(calloc(buffer_size, 1)));
 510   DWORD flags = (in ? (DM_IN_BUFFER) : 0) | DM_OUT_BUFFER | DM_IN_PROMPT;
 511   LONG result = DocumentProperties(window,
 512                                    printer,
 513                                    const_cast<wchar_t*>(printer_name.c_str()),
 514                                    out.get(),
 515                                    in,
 516                                    flags);
 517   if (canceled)
 518     *canceled = (result == IDCANCEL);
 519   if (result != IDOK)
 520     return scoped_ptr<DEVMODE, base::FreeDeleter>();
 521   int size = out->dmSize;
 522   int extra_size = out->dmDriverExtra;
 523   CHECK_GE(buffer_size, size + extra_size);
 524   return out.Pass();
 525 }
 526
 527 }  // namespace printing