printing/backend/print_backend_cups.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/print_backend.h"
   6
   7 #include "build/build_config.h"
   8
   9 #include <dlfcn.h>
  10 #include <errno.h>
  11 #include <pthread.h>
  12
  13 #if !defined(OS_MACOSX)
  14 #include <gcrypt.h>
  15 #endif
  16
  17 #include "base/debug/leak_annotations.h"
  18 #include "base/file_util.h"
  19 #include "base/lazy_instance.h"
  20 #include "base/logging.h"
  21 #include "base/strings/string_number_conversions.h"
  22 #include "base/synchronization/lock.h"
  23 #include "base/values.h"
  24 #include "printing/backend/cups_helper.h"
  25 #include "printing/backend/print_backend_consts.h"
  26 #include "url/gurl.h"
  27
  28 #if !defined(OS_MACOSX)
  29 GCRY_THREAD_OPTION_PTHREAD_IMPL;
  30
  31 namespace {
  32
  33 // Init GCrypt library (needed for CUPS) using pthreads.
  34 // There exists a bug in CUPS library, where it crashed with: "ath.c:184:
  35 // _gcry_ath_mutex_lock: Assertion `*lock == ((ath_mutex_t) 0)' failed."
  36 // It happened when multiple threads tried printing simultaneously.
  37 // Google search for 'gnutls thread safety' provided a solution that
  38 // initialized gcrypt and gnutls.
  39
  40 // TODO(phajdan.jr): Remove this after https://bugs.g10code.com/gnupg/issue1197
  41 // gets fixed on all Linux distros we support (i.e. when they ship libgcrypt
  42 // with the fix).
  43
  44 // Initially, we linked with -lgnutls and simply called gnutls_global_init(),
  45 // but this did not work well since we build one binary on Ubuntu Hardy and
  46 // expect it to run on many Linux distros. (See http://crbug.com/46954)
  47 // So instead we use dlopen() and dlsym() to dynamically load and call
  48 // gnutls_global_init().
  49
  50 class GcryptInitializer {
  51  public:
  52   GcryptInitializer() {
  53     Init();
  54   }
  55
  56  private:
  57   void Init() {
  58     const char* kGnuTlsFiles[] = {
  59       "libgnutls.so.28",
  60       "libgnutls.so.26",
  61       "libgnutls.so",
  62     };
  63     gcry_control(GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread);
  64     for (size_t i = 0; i < arraysize(kGnuTlsFiles); ++i) {
  65       void* gnutls_lib = dlopen(kGnuTlsFiles[i], RTLD_NOW);
  66       if (!gnutls_lib) {
  67         VLOG(1) << "Cannot load " << kGnuTlsFiles[i];
  68         continue;
  69       }
  70       const char* kGnuTlsInitFuncName = "gnutls_global_init";
  71       int (*pgnutls_global_init)(void) = reinterpret_cast<int(*)()>(
  72           dlsym(gnutls_lib, kGnuTlsInitFuncName));
  73       if (!pgnutls_global_init) {
  74         VLOG(1) << "Could not find " << kGnuTlsInitFuncName
  75                 << " in " << kGnuTlsFiles[i];
  76         continue;
  77       }
  78       {
  79         // GnuTLS has a genuine small memory leak that is easier to annotate
  80         // than suppress. See http://crbug.com/176888#c7
  81         // TODO(earthdok): remove this once the leak is fixed.
  82         ANNOTATE_SCOPED_MEMORY_LEAK;
  83         if ((*pgnutls_global_init)() != 0)
  84           LOG(ERROR) << "gnutls_global_init() failed";
  85       }
  86       return;
  87     }
  88     LOG(ERROR) << "Cannot find libgnutls";
  89   }
  90 };
  91
  92 base::LazyInstance<GcryptInitializer> g_gcrypt_initializer =
  93     LAZY_INSTANCE_INITIALIZER;
  94
  95 }  // namespace
  96 #endif  // !defined(OS_MACOSX)
  97
  98 namespace printing {
  99
 100 static const char kCUPSPrinterInfoOpt[] = "printer-info";
 101 static const char kCUPSPrinterStateOpt[] = "printer-state";
 102 static const char kCUPSPrinterTypeOpt[] = "printer-type";
 103 static const char kCUPSPrinterMakeModelOpt[] = "printer-make-and-model";
 104
 105 class PrintBackendCUPS : public PrintBackend {
 106  public:
 107   PrintBackendCUPS(const GURL& print_server_url,
 108                    http_encryption_t encryption, bool blocking);
 109
 110   // PrintBackend implementation.
 111   virtual bool EnumeratePrinters(PrinterList* printer_list) OVERRIDE;
 112   virtual std::string GetDefaultPrinterName() OVERRIDE;
 113   virtual bool GetPrinterSemanticCapsAndDefaults(
 114       const std::string& printer_name,
 115       PrinterSemanticCapsAndDefaults* printer_info) OVERRIDE;
 116   virtual bool GetPrinterCapsAndDefaults(
 117       const std::string& printer_name,
 118       PrinterCapsAndDefaults* printer_info) OVERRIDE;
 119   virtual std::string GetPrinterDriverInfo(
 120       const std::string& printer_name) OVERRIDE;
 121   virtual bool IsValidPrinter(const std::string& printer_name) OVERRIDE;
 122
 123  protected:
 124   virtual ~PrintBackendCUPS() {}
 125
 126  private:
 127   // Following functions are wrappers around corresponding CUPS functions.
 128   // <functions>2()  are called when print server is specified, and plain
 129   // version in another case. There is an issue specifing CUPS_HTTP_DEFAULT
 130   // in the <functions>2(), it does not work in CUPS prior to 1.4.
 131   int GetDests(cups_dest_t** dests);
 132   base::FilePath GetPPD(const char* name);
 133
 134   GURL print_server_url_;
 135   http_encryption_t cups_encryption_;
 136   bool blocking_;
 137 };
 138
 139 PrintBackendCUPS::PrintBackendCUPS(const GURL& print_server_url,
 140                                    http_encryption_t encryption,
 141                                    bool blocking)
 142     : print_server_url_(print_server_url),
 143       cups_encryption_(encryption),
 144       blocking_(blocking) {
 145 }
 146
 147 bool PrintBackendCUPS::EnumeratePrinters(PrinterList* printer_list) {
 148   DCHECK(printer_list);
 149   printer_list->clear();
 150
 151   cups_dest_t* destinations = NULL;
 152   int num_dests = GetDests(&destinations);
 153   if ((num_dests == 0) && (cupsLastError() > IPP_OK_EVENTS_COMPLETE)) {
 154     VLOG(1) << "CUPS: Error getting printers from CUPS server"
 155             << ", server: " << print_server_url_
 156             << ", error: " << static_cast<int>(cupsLastError());
 157     return false;
 158   }
 159
 160   for (int printer_index = 0; printer_index < num_dests; ++printer_index) {
 161     const cups_dest_t& printer = destinations[printer_index];
 162
 163     // CUPS can have 'printers' that are actually scanners. (not MFC)
 164     // At least on Mac. Check for scanners and skip them.
 165     const char* type_str = cupsGetOption(kCUPSPrinterTypeOpt,
 166         printer.num_options, printer.options);
 167     if (type_str != NULL) {
 168       int type;
 169       if (base::StringToInt(type_str, &type) && (type & CUPS_PRINTER_SCANNER))
 170         continue;
 171     }
 172
 173     PrinterBasicInfo printer_info;
 174     printer_info.printer_name = printer.name;
 175     printer_info.is_default = printer.is_default;
 176
 177     const char* info = cupsGetOption(kCUPSPrinterInfoOpt,
 178         printer.num_options, printer.options);
 179     if (info != NULL)
 180       printer_info.printer_description = info;
 181
 182     const char* state = cupsGetOption(kCUPSPrinterStateOpt,
 183         printer.num_options, printer.options);
 184     if (state != NULL)
 185       base::StringToInt(state, &printer_info.printer_status);
 186
 187     const char* drv_info = cupsGetOption(kCUPSPrinterMakeModelOpt,
 188                                          printer.num_options,
 189                                          printer.options);
 190     if (drv_info)
 191       printer_info.options[kDriverInfoTagName] = *drv_info;
 192
 193     // Store printer options.
 194     for (int opt_index = 0; opt_index < printer.num_options; ++opt_index) {
 195       printer_info.options[printer.options[opt_index].name] =
 196           printer.options[opt_index].value;
 197     }
 198
 199     printer_list->push_back(printer_info);
 200   }
 201
 202   cupsFreeDests(num_dests, destinations);
 203
 204   VLOG(1) << "CUPS: Enumerated printers"
 205           << ", server: " << print_server_url_
 206           << ", # of printers: " << printer_list->size();
 207   return true;
 208 }
 209
 210 std::string PrintBackendCUPS::GetDefaultPrinterName() {
 211   // Not using cupsGetDefault() because it lies about the default printer.
 212   cups_dest_t* dests;
 213   int num_dests = GetDests(&dests);
 214   cups_dest_t* dest = cupsGetDest(NULL, NULL, num_dests, dests);
 215   std::string name = dest ? std::string(dest->name) : std::string();
 216   cupsFreeDests(num_dests, dests);
 217   return name;
 218 }
 219
 220 bool PrintBackendCUPS::GetPrinterSemanticCapsAndDefaults(
 221     const std::string& printer_name,
 222     PrinterSemanticCapsAndDefaults* printer_info) {
 223   PrinterCapsAndDefaults info;
 224   if (!GetPrinterCapsAndDefaults(printer_name, &info) )
 225     return false;
 226
 227   return ParsePpdCapabilities(
 228       printer_name, info.printer_capabilities, printer_info);
 229 }
 230
 231 bool PrintBackendCUPS::GetPrinterCapsAndDefaults(
 232     const std::string& printer_name,
 233     PrinterCapsAndDefaults* printer_info) {
 234   DCHECK(printer_info);
 235
 236   VLOG(1) << "CUPS: Getting caps and defaults"
 237           << ", printer name: " << printer_name;
 238
 239   base::FilePath ppd_path(GetPPD(printer_name.c_str()));
 240   // In some cases CUPS failed to get ppd file.
 241   if (ppd_path.empty()) {
 242     LOG(ERROR) << "CUPS: Failed to get PPD"
 243                << ", printer name: " << printer_name;
 244     return false;
 245   }
 246
 247   std::string content;
 248   bool res = base::ReadFileToString(ppd_path, &content);
 249
 250   base::DeleteFile(ppd_path, false);
 251
 252   if (res) {
 253     printer_info->printer_capabilities.swap(content);
 254     printer_info->caps_mime_type = "application/pagemaker";
 255     // In CUPS, printer defaults is a part of PPD file. Nothing to upload here.
 256     printer_info->printer_defaults.clear();
 257     printer_info->defaults_mime_type.clear();
 258   }
 259
 260   return res;
 261 }
 262
 263 std::string PrintBackendCUPS::GetPrinterDriverInfo(
 264     const std::string& printer_name) {
 265   cups_dest_t* destinations = NULL;
 266   int num_dests = GetDests(&destinations);
 267   std::string result;
 268   for (int printer_index = 0; printer_index < num_dests; ++printer_index) {
 269     const cups_dest_t& printer = destinations[printer_index];
 270     if (printer_name == printer.name) {
 271       const char* info = cupsGetOption(kCUPSPrinterMakeModelOpt,
 272                                        printer.num_options,
 273                                        printer.options);
 274       if (info)
 275         result = *info;
 276     }
 277   }
 278
 279   cupsFreeDests(num_dests, destinations);
 280   return result;
 281 }
 282
 283 bool PrintBackendCUPS::IsValidPrinter(const std::string& printer_name) {
 284   // This is not very efficient way to get specific printer info. CUPS 1.4
 285   // supports cupsGetNamedDest() function. However, CUPS 1.4 is not available
 286   // everywhere (for example, it supported from Mac OS 10.6 only).
 287   PrinterList printer_list;
 288   EnumeratePrinters(&printer_list);
 289
 290   PrinterList::iterator it;
 291   for (it = printer_list.begin(); it != printer_list.end(); ++it)
 292     if (it->printer_name == printer_name)
 293       return true;
 294   return false;
 295 }
 296
 297 scoped_refptr<PrintBackend> PrintBackend::CreateInstance(
 298     const base::DictionaryValue* print_backend_settings) {
 299 #if !defined(OS_MACOSX)
 300   // Initialize gcrypt library.
 301   g_gcrypt_initializer.Get();
 302 #endif
 303
 304   std::string print_server_url_str, cups_blocking;
 305   int encryption = HTTP_ENCRYPT_NEVER;
 306   if (print_backend_settings) {
 307     print_backend_settings->GetString(kCUPSPrintServerURL,
 308                                       &print_server_url_str);
 309
 310     print_backend_settings->GetString(kCUPSBlocking,
 311                                       &cups_blocking);
 312
 313     print_backend_settings->GetInteger(kCUPSEncryption, &encryption);
 314   }
 315   GURL print_server_url(print_server_url_str.c_str());
 316   return new PrintBackendCUPS(print_server_url,
 317                               static_cast<http_encryption_t>(encryption),
 318                               cups_blocking == kValueTrue);
 319 }
 320
 321 int PrintBackendCUPS::GetDests(cups_dest_t** dests) {
 322   if (print_server_url_.is_empty()) {  // Use default (local) print server.
 323     return cupsGetDests(dests);
 324   } else {
 325     HttpConnectionCUPS http(print_server_url_, cups_encryption_);
 326     http.SetBlocking(blocking_);
 327     return cupsGetDests2(http.http(), dests);
 328   }
 329 }
 330
 331 base::FilePath PrintBackendCUPS::GetPPD(const char* name) {
 332   // cupsGetPPD returns a filename stored in a static buffer in CUPS.
 333   // Protect this code with lock.
 334   CR_DEFINE_STATIC_LOCAL(base::Lock, ppd_lock, ());
 335   base::AutoLock ppd_autolock(ppd_lock);
 336   base::FilePath ppd_path;
 337   const char* ppd_file_path = NULL;
 338   if (print_server_url_.is_empty()) {  // Use default (local) print server.
 339     ppd_file_path = cupsGetPPD(name);
 340     if (ppd_file_path)
 341       ppd_path = base::FilePath(ppd_file_path);
 342   } else {
 343     // cupsGetPPD2 gets stuck sometimes in an infinite time due to network
 344     // configuration/issues. To prevent that, use non-blocking http connection
 345     // here.
 346     // Note: After looking at CUPS sources, it looks like non-blocking
 347     // connection will timeout after 10 seconds of no data period. And it will
 348     // return the same way as if data was completely and sucessfully downloaded.
 349     HttpConnectionCUPS http(print_server_url_, cups_encryption_);
 350     http.SetBlocking(blocking_);
 351     ppd_file_path = cupsGetPPD2(http.http(), name);
 352     // Check if the get full PPD, since non-blocking call may simply return
 353     // normally after timeout expired.
 354     if (ppd_file_path) {
 355       // There is no reliable way right now to detect full and complete PPD
 356       // get downloaded. If we reach http timeout, it may simply return
 357       // downloaded part as a full response. It might be good enough to check
 358       // http->data_remaining or http->_data_remaining, unfortunately http_t
 359       // is an internal structure and fields are not exposed in CUPS headers.
 360       // httpGetLength or httpGetLength2 returning the full content size.
 361       // Comparing file size against that content length might be unreliable
 362       // since some http reponses are encoded and content_length > file size.
 363       // Let's just check for the obvious CUPS and http errors here.
 364       ppd_path = base::FilePath(ppd_file_path);
 365       ipp_status_t error_code = cupsLastError();
 366       int http_error = httpError(http.http());
 367       if (error_code > IPP_OK_EVENTS_COMPLETE || http_error != 0) {
 368         LOG(ERROR) << "Error downloading PPD file"
 369                    << ", name: " << name
 370                    << ", CUPS error: " << static_cast<int>(error_code)
 371                    << ", HTTP error: " << http_error;
 372         base::DeleteFile(ppd_path, false);
 373         ppd_path.clear();
 374       }
 375     }
 376   }
 377   return ppd_path;
 378 }
 379
 380 }  // namespace printing