Home | History | Annotate | Download | only in cloud_print 
      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 "chrome/service/cloud_print/print_system.h"
      6 
      7 #include <cups/cups.h>
      8 #include <dlfcn.h>
      9 #include <errno.h>
     10 #include <pthread.h>
     11 
     12 #include <algorithm>
     13 #include <list>
     14 #include <map>
     15 
     16 #include "base/bind.h"
     17 #include "base/files/file_path.h"
     18 #include "base/json/json_reader.h"
     19 #include "base/logging.h"
     20 #include "base/md5.h"
     21 #include "base/memory/scoped_ptr.h"
     22 #include "base/message_loop/message_loop.h"
     23 #include "base/rand_util.h"
     24 #include "base/strings/string_number_conversions.h"
     25 #include "base/strings/string_util.h"
     26 #include "base/strings/utf_string_conversions.h"
     27 #include "base/values.h"
     28 #include "chrome/common/cloud_print/cloud_print_constants.h"
     29 #include "chrome/common/crash_keys.h"
     30 #include "chrome/service/cloud_print/cloud_print_service_helpers.h"
     31 #include "grit/generated_resources.h"
     32 #include "printing/backend/cups_helper.h"
     33 #include "printing/backend/print_backend.h"
     34 #include "printing/backend/print_backend_consts.h"
     35 #include "ui/base/l10n/l10n_util.h"
     36 #include "url/gurl.h"
     37 
     38 namespace {
     39 
     40 // Print system config options.
     41 const char kCUPSPrintServerURLs[] = "print_server_urls";
     42 const char kCUPSUpdateTimeoutMs[] = "update_timeout_ms";
     43 const char kCUPSNotifyDelete[] = "notify_delete";
     44 const char kCUPSSupportedMimeTipes[] = "supported_mime_types";
     45 
     46 // Default mime types supported by CUPS
     47 // http://www.cups.org/articles.php?L205+TFAQ+Q
     48 const char kCUPSDefaultSupportedTypes[] =
     49     "application/pdf,application/postscript,image/jpeg,image/png,image/gif";
     50 
     51 // Time interval to check for printer's updates.
     52 const int kCheckForPrinterUpdatesMinutes = 5;
     53 
     54 // Job update timeout
     55 const int kJobUpdateTimeoutSeconds = 5;
     56 
     57 // Job id for dry run (it should not affect CUPS job ids, since 0 job-id is
     58 // invalid in CUPS.
     59 const int kDryRunJobId = 0;
     60 
     61 }  // namespace
     62 
     63 namespace cloud_print {
     64 
     65 struct PrintServerInfoCUPS {
     66   GURL url;
     67   scoped_refptr<printing::PrintBackend> backend;
     68   printing::PrinterList printers;
     69   // CapsMap cache PPD until the next update and give a fast access to it by
     70   // printer name. PPD request is relatively expensive and this should minimize
     71   // the number of requests.
     72   typedef std::map<std::string, printing::PrinterCapsAndDefaults> CapsMap;
     73   CapsMap caps_cache;
     74 };
     75 
     76 class PrintSystemCUPS : public PrintSystem {
     77  public:
     78   explicit PrintSystemCUPS(const base::DictionaryValue* print_system_settings);
     79 
     80   // PrintSystem implementation.
     81   virtual PrintSystemResult Init() OVERRIDE;
     82   virtual PrintSystem::PrintSystemResult EnumeratePrinters(
     83       printing::PrinterList* printer_list) OVERRIDE;
     84   virtual void GetPrinterCapsAndDefaults(
     85       const std::string& printer_name,
     86       const PrinterCapsAndDefaultsCallback& callback) OVERRIDE;
     87   virtual bool IsValidPrinter(const std::string& printer_name) OVERRIDE;
     88   virtual bool ValidatePrintTicket(
     89       const std::string& printer_name,
     90       const std::string& print_ticket_data,
     91       const std::string& print_ticket_mime_type) OVERRIDE;
     92   virtual bool GetJobDetails(const std::string& printer_name,
     93                              PlatformJobId job_id,
     94                              PrintJobDetails *job_details) OVERRIDE;
     95   virtual PrintSystem::PrintServerWatcher* CreatePrintServerWatcher() OVERRIDE;
     96   virtual PrintSystem::PrinterWatcher* CreatePrinterWatcher(
     97       const std::string& printer_name) OVERRIDE;
     98   virtual PrintSystem::JobSpooler* CreateJobSpooler() OVERRIDE;
     99   virtual bool UseCddAndCjt() OVERRIDE;
    100   virtual std::string GetSupportedMimeTypes() OVERRIDE;
    101 
    102   // Helper functions.
    103   PlatformJobId SpoolPrintJob(const std::string& print_ticket,
    104                               const base::FilePath& print_data_file_path,
    105                               const std::string& print_data_mime_type,
    106                               const std::string& printer_name,
    107                               const std::string& job_title,
    108                               const std::vector<std::string>& tags,
    109                               bool* dry_run);
    110   bool GetPrinterInfo(const std::string& printer_name,
    111                       printing::PrinterBasicInfo* info);
    112   bool ParsePrintTicket(const std::string& print_ticket,
    113                         std::map<std::string, std::string>* options);
    114 
    115   // Synchronous version of GetPrinterCapsAndDefaults.
    116   bool GetPrinterCapsAndDefaults(
    117       const std::string& printer_name,
    118       printing::PrinterCapsAndDefaults* printer_info);
    119 
    120   base::TimeDelta GetUpdateTimeout() const {
    121     return update_timeout_;
    122   }
    123 
    124   bool NotifyDelete() const {
    125     // Notify about deleted printers only when we
    126     // fetched printers list without errors.
    127     return notify_delete_ && printer_enum_succeeded_;
    128   }
    129 
    130  private:
    131   virtual ~PrintSystemCUPS() {}
    132 
    133   // Following functions are wrappers around corresponding CUPS functions.
    134   // <functions>2()  are called when print server is specified, and plain
    135   // version in another case. There is an issue specifing CUPS_HTTP_DEFAULT
    136   // in the <functions>2(), it does not work in CUPS prior to 1.4.
    137   int GetJobs(cups_job_t** jobs, const GURL& url,
    138               http_encryption_t encryption, const char* name,
    139               int myjobs, int whichjobs);
    140   int PrintFile(const GURL& url, http_encryption_t encryption,
    141                 const char* name, const char* filename,
    142                 const char* title, int num_options, cups_option_t* options);
    143 
    144   void InitPrintBackends(const base::DictionaryValue* print_system_settings);
    145   void AddPrintServer(const std::string& url);
    146 
    147   void UpdatePrinters();
    148 
    149   // Full name contains print server url:port and printer name. Short name
    150   // is the name of the printer in the CUPS server.
    151   std::string MakeFullPrinterName(const GURL& url,
    152                                   const std::string& short_printer_name);
    153   PrintServerInfoCUPS* FindServerByFullName(
    154       const std::string& full_printer_name, std::string* short_printer_name);
    155 
    156   // Helper method to invoke a PrinterCapsAndDefaultsCallback.
    157   static void RunCapsCallback(
    158       const PrinterCapsAndDefaultsCallback& callback,
    159       bool succeeded,
    160       const std::string& printer_name,
    161       const printing::PrinterCapsAndDefaults& printer_info);
    162 
    163   // PrintServerList contains information about all print servers and backends
    164   // this proxy is connected to.
    165   typedef std::list<PrintServerInfoCUPS> PrintServerList;
    166   PrintServerList print_servers_;
    167 
    168   base::TimeDelta update_timeout_;
    169   bool initialized_;
    170   bool printer_enum_succeeded_;
    171   bool notify_delete_;
    172   http_encryption_t cups_encryption_;
    173   std::string supported_mime_types_;
    174 };
    175 
    176 class PrintServerWatcherCUPS
    177   : public PrintSystem::PrintServerWatcher {
    178  public:
    179   explicit PrintServerWatcherCUPS(PrintSystemCUPS* print_system)
    180       : print_system_(print_system),
    181         delegate_(NULL) {
    182   }
    183 
    184   // PrintSystem::PrintServerWatcher implementation.
    185   virtual bool StartWatching(
    186       PrintSystem::PrintServerWatcher::Delegate* delegate) OVERRIDE {
    187     delegate_ = delegate;
    188     printers_hash_ = GetPrintersHash();
    189     base::MessageLoop::current()->PostDelayedTask(
    190         FROM_HERE,
    191         base::Bind(&PrintServerWatcherCUPS::CheckForUpdates, this),
    192         print_system_->GetUpdateTimeout());
    193     return true;
    194   }
    195 
    196   virtual bool StopWatching() OVERRIDE {
    197     delegate_ = NULL;
    198     return true;
    199   }
    200 
    201   void CheckForUpdates() {
    202     if (delegate_ == NULL)
    203       return;  // Orphan call. We have been stopped already.
    204     VLOG(1) << "CP_CUPS: Checking for new printers";
    205     std::string new_hash = GetPrintersHash();
    206     if (printers_hash_ != new_hash) {
    207       printers_hash_ = new_hash;
    208       delegate_->OnPrinterAdded();
    209     }
    210     base::MessageLoop::current()->PostDelayedTask(
    211         FROM_HERE,
    212         base::Bind(&PrintServerWatcherCUPS::CheckForUpdates, this),
    213         print_system_->GetUpdateTimeout());
    214   }
    215 
    216  protected:
    217   virtual ~PrintServerWatcherCUPS() {
    218     StopWatching();
    219   }
    220 
    221  private:
    222   std::string GetPrintersHash() {
    223     printing::PrinterList printer_list;
    224     print_system_->EnumeratePrinters(&printer_list);
    225 
    226     // Sort printer names.
    227     std::vector<std::string> printers;
    228     printing::PrinterList::iterator it;
    229     for (it = printer_list.begin(); it != printer_list.end(); ++it)
    230       printers.push_back(it->printer_name);
    231     std::sort(printers.begin(), printers.end());
    232 
    233     std::string to_hash;
    234     for (size_t i = 0; i < printers.size(); i++)
    235       to_hash += printers[i];
    236 
    237     return base::MD5String(to_hash);
    238   }
    239 
    240   scoped_refptr<PrintSystemCUPS> print_system_;
    241   PrintSystem::PrintServerWatcher::Delegate* delegate_;
    242   std::string printers_hash_;
    243 
    244   DISALLOW_COPY_AND_ASSIGN(PrintServerWatcherCUPS);
    245 };
    246 
    247 class PrinterWatcherCUPS
    248     : public PrintSystem::PrinterWatcher {
    249  public:
    250   PrinterWatcherCUPS(PrintSystemCUPS* print_system,
    251                      const std::string& printer_name)
    252       : printer_name_(printer_name),
    253         delegate_(NULL),
    254         print_system_(print_system) {
    255   }
    256 
    257   // PrintSystem::PrinterWatcher implementation.
    258   virtual bool StartWatching(
    259       PrintSystem::PrinterWatcher::Delegate* delegate) OVERRIDE{
    260     scoped_refptr<printing::PrintBackend> print_backend(
    261         printing::PrintBackend::CreateInstance(NULL));
    262     crash_keys::ScopedPrinterInfo crash_key(
    263         print_backend->GetPrinterDriverInfo(printer_name_));
    264     if (delegate_ != NULL)
    265       StopWatching();
    266     delegate_ = delegate;
    267     settings_hash_ = GetSettingsHash();
    268     // Schedule next job status update.
    269     base::MessageLoop::current()->PostDelayedTask(
    270         FROM_HERE,
    271         base::Bind(&PrinterWatcherCUPS::JobStatusUpdate, this),
    272         base::TimeDelta::FromSeconds(kJobUpdateTimeoutSeconds));
    273     // Schedule next printer check.
    274     // TODO(gene): Randomize time for the next printer update.
    275     base::MessageLoop::current()->PostDelayedTask(
    276         FROM_HERE,
    277         base::Bind(&PrinterWatcherCUPS::PrinterUpdate, this),
    278         print_system_->GetUpdateTimeout());
    279     return true;
    280   }
    281 
    282   virtual bool StopWatching() OVERRIDE{
    283     delegate_ = NULL;
    284     return true;
    285   }
    286 
    287   virtual bool GetCurrentPrinterInfo(
    288       printing::PrinterBasicInfo* printer_info) OVERRIDE {
    289     DCHECK(printer_info);
    290     return print_system_->GetPrinterInfo(printer_name_, printer_info);
    291   }
    292 
    293   void JobStatusUpdate() {
    294     if (delegate_ == NULL)
    295       return;  // Orphan call. We have been stopped already.
    296     // For CUPS proxy, we are going to fire OnJobChanged notification
    297     // periodically. Higher level will check if there are any outstanding
    298     // jobs for this printer and check their status. If printer has no
    299     // outstanding jobs, OnJobChanged() will do nothing.
    300     delegate_->OnJobChanged();
    301     base::MessageLoop::current()->PostDelayedTask(
    302         FROM_HERE,
    303         base::Bind(&PrinterWatcherCUPS::JobStatusUpdate, this),
    304         base::TimeDelta::FromSeconds(kJobUpdateTimeoutSeconds));
    305   }
    306 
    307   void PrinterUpdate() {
    308     if (delegate_ == NULL)
    309       return;  // Orphan call. We have been stopped already.
    310     VLOG(1) << "CP_CUPS: Checking for updates"
    311             << ", printer name: " << printer_name_;
    312     if (print_system_->NotifyDelete() &&
    313         !print_system_->IsValidPrinter(printer_name_)) {
    314       delegate_->OnPrinterDeleted();
    315       VLOG(1) << "CP_CUPS: Printer deleted"
    316               << ", printer name: " << printer_name_;
    317     } else {
    318       std::string new_hash = GetSettingsHash();
    319       if (settings_hash_ != new_hash) {
    320         settings_hash_ = new_hash;
    321         delegate_->OnPrinterChanged();
    322         VLOG(1) << "CP_CUPS: Printer configuration changed"
    323                 << ", printer name: " << printer_name_;
    324       }
    325     }
    326     base::MessageLoop::current()->PostDelayedTask(
    327         FROM_HERE,
    328         base::Bind(&PrinterWatcherCUPS::PrinterUpdate, this),
    329         print_system_->GetUpdateTimeout());
    330   }
    331 
    332  protected:
    333   virtual ~PrinterWatcherCUPS() {
    334     StopWatching();
    335   }
    336 
    337  private:
    338   std::string GetSettingsHash() {
    339     printing::PrinterBasicInfo info;
    340     if (!print_system_->GetPrinterInfo(printer_name_, &info))
    341       return std::string();
    342 
    343     printing::PrinterCapsAndDefaults caps;
    344     if (!print_system_->GetPrinterCapsAndDefaults(printer_name_, &caps))
    345       return std::string();
    346 
    347     std::string to_hash(info.printer_name);
    348     to_hash += info.printer_description;
    349     std::map<std::string, std::string>::const_iterator it;
    350     for (it = info.options.begin(); it != info.options.end(); ++it) {
    351       to_hash += it->first;
    352       to_hash += it->second;
    353     }
    354 
    355     to_hash += caps.printer_capabilities;
    356     to_hash += caps.caps_mime_type;
    357     to_hash += caps.printer_defaults;
    358     to_hash += caps.defaults_mime_type;
    359 
    360     return base::MD5String(to_hash);
    361   }
    362   std::string printer_name_;
    363   PrintSystem::PrinterWatcher::Delegate* delegate_;
    364   scoped_refptr<PrintSystemCUPS> print_system_;
    365   std::string settings_hash_;
    366 
    367   DISALLOW_COPY_AND_ASSIGN(PrinterWatcherCUPS);
    368 };
    369 
    370 class JobSpoolerCUPS : public PrintSystem::JobSpooler {
    371  public:
    372   explicit JobSpoolerCUPS(PrintSystemCUPS* print_system)
    373       : print_system_(print_system) {
    374     DCHECK(print_system_.get());
    375   }
    376 
    377   // PrintSystem::JobSpooler implementation.
    378   virtual bool Spool(const std::string& print_ticket,
    379                      const std::string& print_ticket_mime_type,
    380                      const base::FilePath& print_data_file_path,
    381                      const std::string& print_data_mime_type,
    382                      const std::string& printer_name,
    383                      const std::string& job_title,
    384                      const std::vector<std::string>& tags,
    385                      JobSpooler::Delegate* delegate) OVERRIDE{
    386     DCHECK(delegate);
    387     bool dry_run = false;
    388     int job_id = print_system_->SpoolPrintJob(
    389         print_ticket, print_data_file_path, print_data_mime_type,
    390         printer_name, job_title, tags, &dry_run);
    391     base::MessageLoop::current()->PostTask(
    392         FROM_HERE,
    393         base::Bind(&JobSpoolerCUPS::NotifyDelegate, delegate, job_id, dry_run));
    394     return true;
    395   }
    396 
    397   static void NotifyDelegate(JobSpooler::Delegate* delegate,
    398                              int job_id, bool dry_run) {
    399     if (dry_run || job_id)
    400       delegate->OnJobSpoolSucceeded(job_id);
    401     else
    402       delegate->OnJobSpoolFailed();
    403   }
    404 
    405  protected:
    406   virtual ~JobSpoolerCUPS() {}
    407 
    408  private:
    409   scoped_refptr<PrintSystemCUPS> print_system_;
    410 
    411   DISALLOW_COPY_AND_ASSIGN(JobSpoolerCUPS);
    412 };
    413 
    414 PrintSystemCUPS::PrintSystemCUPS(
    415     const base::DictionaryValue* print_system_settings)
    416     : update_timeout_(base::TimeDelta::FromMinutes(
    417         kCheckForPrinterUpdatesMinutes)),
    418       initialized_(false),
    419       printer_enum_succeeded_(false),
    420       notify_delete_(true),
    421       cups_encryption_(HTTP_ENCRYPT_NEVER),
    422       supported_mime_types_(kCUPSDefaultSupportedTypes) {
    423   if (print_system_settings) {
    424     int timeout;
    425     if (print_system_settings->GetInteger(kCUPSUpdateTimeoutMs, &timeout))
    426       update_timeout_ = base::TimeDelta::FromMilliseconds(timeout);
    427 
    428     int encryption;
    429     if (print_system_settings->GetInteger(kCUPSEncryption, &encryption))
    430       cups_encryption_ =
    431           static_cast<http_encryption_t>(encryption);
    432 
    433     bool notify_delete = true;
    434     if (print_system_settings->GetBoolean(kCUPSNotifyDelete, &notify_delete))
    435       notify_delete_ = notify_delete;
    436 
    437     std::string types;
    438     if (print_system_settings->GetString(kCUPSSupportedMimeTipes, &types))
    439       supported_mime_types_ = types;
    440   }
    441 
    442   InitPrintBackends(print_system_settings);
    443 }
    444 
    445 void PrintSystemCUPS::InitPrintBackends(
    446     const base::DictionaryValue* print_system_settings) {
    447   const base::ListValue* url_list;
    448   if (print_system_settings &&
    449       print_system_settings->GetList(kCUPSPrintServerURLs, &url_list)) {
    450     for (size_t i = 0; i < url_list->GetSize(); i++) {
    451       std::string print_server_url;
    452       if (url_list->GetString(i, &print_server_url))
    453         AddPrintServer(print_server_url);
    454     }
    455   }
    456 
    457   // If server list is empty, use default print server.
    458   if (print_servers_.empty())
    459     AddPrintServer(std::string());
    460 }
    461 
    462 void PrintSystemCUPS::AddPrintServer(const std::string& url) {
    463   if (url.empty())
    464     LOG(WARNING) << "No print server specified. Using default print server.";
    465 
    466   // Get Print backend for the specific print server.
    467   base::DictionaryValue backend_settings;
    468   backend_settings.SetString(kCUPSPrintServerURL, url);
    469 
    470   // Make CUPS requests non-blocking.
    471   backend_settings.SetString(kCUPSBlocking, kValueFalse);
    472 
    473   // Set encryption for backend.
    474   backend_settings.SetInteger(kCUPSEncryption, cups_encryption_);
    475 
    476   PrintServerInfoCUPS print_server;
    477   print_server.backend =
    478     printing::PrintBackend::CreateInstance(&backend_settings);
    479   print_server.url = GURL(url.c_str());
    480 
    481   print_servers_.push_back(print_server);
    482 }
    483 
    484 PrintSystem::PrintSystemResult PrintSystemCUPS::Init() {
    485   UpdatePrinters();
    486   initialized_ = true;
    487   return PrintSystemResult(true, std::string());
    488 }
    489 
    490 void PrintSystemCUPS::UpdatePrinters() {
    491   PrintServerList::iterator it;
    492   printer_enum_succeeded_ = true;
    493   for (it = print_servers_.begin(); it != print_servers_.end(); ++it) {
    494     if (!it->backend->EnumeratePrinters(&it->printers))
    495       printer_enum_succeeded_ = false;
    496     it->caps_cache.clear();
    497     printing::PrinterList::iterator printer_it;
    498     for (printer_it = it->printers.begin();
    499         printer_it != it->printers.end(); ++printer_it) {
    500       printer_it->printer_name = MakeFullPrinterName(it->url,
    501                                                      printer_it->printer_name);
    502     }
    503     VLOG(1) << "CP_CUPS: Updated printers list"
    504             << ", server: " << it->url
    505             << ", # of printers: " << it->printers.size();
    506   }
    507 
    508   // Schedule next update.
    509   base::MessageLoop::current()->PostDelayedTask(
    510       FROM_HERE,
    511       base::Bind(&PrintSystemCUPS::UpdatePrinters, this),
    512       GetUpdateTimeout());
    513 }
    514 
    515 PrintSystem::PrintSystemResult PrintSystemCUPS::EnumeratePrinters(
    516     printing::PrinterList* printer_list) {
    517   DCHECK(initialized_);
    518   printer_list->clear();
    519   PrintServerList::iterator it;
    520   for (it = print_servers_.begin(); it != print_servers_.end(); ++it) {
    521     printer_list->insert(printer_list->end(),
    522         it->printers.begin(), it->printers.end());
    523   }
    524   VLOG(1) << "CP_CUPS: Total printers enumerated: " << printer_list->size();
    525   // TODO(sanjeevr): Maybe some day we want to report the actual server names
    526   // for which the enumeration failed.
    527   return PrintSystemResult(printer_enum_succeeded_, std::string());
    528 }
    529 
    530 void PrintSystemCUPS::GetPrinterCapsAndDefaults(
    531     const std::string& printer_name,
    532     const PrinterCapsAndDefaultsCallback& callback) {
    533   printing::PrinterCapsAndDefaults printer_info;
    534   bool succeeded = GetPrinterCapsAndDefaults(printer_name, &printer_info);
    535   base::MessageLoop::current()->PostTask(
    536       FROM_HERE,
    537       base::Bind(&PrintSystemCUPS::RunCapsCallback,
    538                  callback,
    539                  succeeded,
    540                  printer_name,
    541                  printer_info));
    542 }
    543 
    544 bool PrintSystemCUPS::IsValidPrinter(const std::string& printer_name) {
    545   return GetPrinterInfo(printer_name, NULL);
    546 }
    547 
    548 bool PrintSystemCUPS::ValidatePrintTicket(
    549     const std::string& printer_name,
    550     const std::string& print_ticket_data,
    551     const std::string& print_ticket_mime_type) {
    552   DCHECK(initialized_);
    553   scoped_ptr<base::Value> ticket_value(
    554       base::JSONReader::Read(print_ticket_data));
    555   return ticket_value != NULL &&
    556          ticket_value->IsType(base::Value::TYPE_DICTIONARY);
    557 }
    558 
    559 // Print ticket on linux is a JSON string containing only one dictionary.
    560 bool PrintSystemCUPS::ParsePrintTicket(
    561     const std::string& print_ticket,
    562     std::map<std::string, std::string>* options) {
    563   DCHECK(options);
    564   scoped_ptr<base::Value> ticket_value(base::JSONReader::Read(print_ticket));
    565   if (ticket_value == NULL ||
    566       !ticket_value->IsType(base::Value::TYPE_DICTIONARY)) {
    567     return false;
    568   }
    569 
    570   options->clear();
    571   base::DictionaryValue* ticket_dict =
    572       static_cast<base::DictionaryValue*>(ticket_value.get());
    573   for (base::DictionaryValue::Iterator it(*ticket_dict); !it.IsAtEnd();
    574        it.Advance()) {
    575     std::string value;
    576     if (it.value().GetAsString(&value))
    577       (*options)[it.key()] = value;
    578   }
    579 
    580   return true;
    581 }
    582 
    583 bool PrintSystemCUPS::GetPrinterCapsAndDefaults(
    584     const std::string& printer_name,
    585     printing::PrinterCapsAndDefaults* printer_info) {
    586   DCHECK(initialized_);
    587   std::string short_printer_name;
    588   PrintServerInfoCUPS* server_info =
    589       FindServerByFullName(printer_name, &short_printer_name);
    590   if (!server_info)
    591     return false;
    592 
    593   PrintServerInfoCUPS::CapsMap::iterator caps_it =
    594       server_info->caps_cache.find(printer_name);
    595   if (caps_it != server_info->caps_cache.end()) {
    596     *printer_info = caps_it->second;
    597     return true;
    598   }
    599 
    600   // TODO(gene): Retry multiple times in case of error.
    601   crash_keys::ScopedPrinterInfo crash_key(
    602       server_info->backend->GetPrinterDriverInfo(short_printer_name));
    603   if (!server_info->backend->GetPrinterCapsAndDefaults(short_printer_name,
    604                                                        printer_info) ) {
    605     return false;
    606   }
    607 
    608   server_info->caps_cache[printer_name] = *printer_info;
    609   return true;
    610 }
    611 
    612 bool PrintSystemCUPS::GetJobDetails(const std::string& printer_name,
    613                                     PlatformJobId job_id,
    614                                     PrintJobDetails *job_details) {
    615   DCHECK(initialized_);
    616   DCHECK(job_details);
    617 
    618   std::string short_printer_name;
    619   PrintServerInfoCUPS* server_info =
    620       FindServerByFullName(printer_name, &short_printer_name);
    621   if (!server_info)
    622     return false;
    623 
    624   crash_keys::ScopedPrinterInfo crash_key(
    625       server_info->backend->GetPrinterDriverInfo(short_printer_name));
    626   cups_job_t* jobs = NULL;
    627   int num_jobs = GetJobs(&jobs, server_info->url, cups_encryption_,
    628                          short_printer_name.c_str(), 1, -1);
    629   bool error = (num_jobs == 0) && (cupsLastError() > IPP_OK_EVENTS_COMPLETE);
    630   if (error) {
    631     VLOG(1) << "CP_CUPS: Error getting jobs from CUPS server"
    632             << ", printer name:" << printer_name
    633             << ", error: " << static_cast<int>(cupsLastError());
    634     return false;
    635   }
    636 
    637   // Check if the request is for dummy dry run job.
    638   // We check this after calling GetJobs API to see if this printer is actually
    639   // accessible through CUPS.
    640   if (job_id == kDryRunJobId) {
    641     job_details->status = PRINT_JOB_STATUS_COMPLETED;
    642     VLOG(1) << "CP_CUPS: Dry run job succeeded"
    643             << ", printer name: " << printer_name;
    644     return true;
    645   }
    646 
    647   bool found = false;
    648   for (int i = 0; i < num_jobs; i++) {
    649     if (jobs[i].id == job_id) {
    650       found = true;
    651       switch (jobs[i].state) {
    652         case IPP_JOB_PENDING :
    653         case IPP_JOB_HELD :
    654         case IPP_JOB_PROCESSING :
    655           job_details->status = PRINT_JOB_STATUS_IN_PROGRESS;
    656           break;
    657         case IPP_JOB_STOPPED :
    658         case IPP_JOB_CANCELLED :
    659         case IPP_JOB_ABORTED :
    660           job_details->status = PRINT_JOB_STATUS_ERROR;
    661           break;
    662         case IPP_JOB_COMPLETED :
    663           job_details->status = PRINT_JOB_STATUS_COMPLETED;
    664           break;
    665         default:
    666           job_details->status = PRINT_JOB_STATUS_INVALID;
    667       }
    668       job_details->platform_status_flags = jobs[i].state;
    669 
    670       // We don't have any details on the number of processed pages here.
    671       break;
    672     }
    673   }
    674 
    675   if (found)
    676     VLOG(1) << "CP_CUPS: Job found"
    677             << ", printer name: " << printer_name
    678             << ", cups job id: " << job_id
    679             << ", cups job status: " << job_details->status;
    680   else
    681     LOG(WARNING) << "CP_CUPS: Job not found"
    682                  << ", printer name: " << printer_name
    683                  << ", cups job id: " << job_id;
    684 
    685   cupsFreeJobs(num_jobs, jobs);
    686   return found;
    687 }
    688 
    689 bool PrintSystemCUPS::GetPrinterInfo(const std::string& printer_name,
    690                                      printing::PrinterBasicInfo* info) {
    691   DCHECK(initialized_);
    692   if (info)
    693     VLOG(1) << "CP_CUPS: Getting printer info"
    694             << ", printer name: " << printer_name;
    695 
    696   std::string short_printer_name;
    697   PrintServerInfoCUPS* server_info =
    698       FindServerByFullName(printer_name, &short_printer_name);
    699   if (!server_info)
    700     return false;
    701 
    702   printing::PrinterList::iterator it;
    703   for (it = server_info->printers.begin();
    704       it != server_info->printers.end(); ++it) {
    705     if (it->printer_name == printer_name) {
    706       if (info)
    707         *info = *it;
    708       return true;
    709     }
    710   }
    711   return false;
    712 }
    713 
    714 PrintSystem::PrintServerWatcher*
    715 PrintSystemCUPS::CreatePrintServerWatcher() {
    716   DCHECK(initialized_);
    717   return new PrintServerWatcherCUPS(this);
    718 }
    719 
    720 PrintSystem::PrinterWatcher* PrintSystemCUPS::CreatePrinterWatcher(
    721     const std::string& printer_name) {
    722   DCHECK(initialized_);
    723   DCHECK(!printer_name.empty());
    724   return new PrinterWatcherCUPS(this, printer_name);
    725 }
    726 
    727 PrintSystem::JobSpooler* PrintSystemCUPS::CreateJobSpooler() {
    728   DCHECK(initialized_);
    729   return new JobSpoolerCUPS(this);
    730 }
    731 
    732 bool PrintSystemCUPS::UseCddAndCjt() {
    733   return false;
    734 }
    735 
    736 std::string PrintSystemCUPS::GetSupportedMimeTypes() {
    737   return supported_mime_types_;
    738 }
    739 
    740 scoped_refptr<PrintSystem> PrintSystem::CreateInstance(
    741     const base::DictionaryValue* print_system_settings) {
    742   return new PrintSystemCUPS(print_system_settings);
    743 }
    744 
    745 int PrintSystemCUPS::PrintFile(const GURL& url, http_encryption_t encryption,
    746                                const char* name, const char* filename,
    747                                const char* title, int num_options,
    748                                cups_option_t* options) {
    749   if (url.is_empty()) {  // Use default (local) print server.
    750     return cupsPrintFile(name, filename, title, num_options, options);
    751   } else {
    752     printing::HttpConnectionCUPS http(url, encryption);
    753     http.SetBlocking(false);
    754     return cupsPrintFile2(http.http(), name, filename,
    755                           title, num_options, options);
    756   }
    757 }
    758 
    759 int PrintSystemCUPS::GetJobs(cups_job_t** jobs, const GURL& url,
    760                              http_encryption_t encryption,
    761                              const char* name, int myjobs, int whichjobs) {
    762   if (url.is_empty()) {  // Use default (local) print server.
    763     return cupsGetJobs(jobs, name, myjobs, whichjobs);
    764   } else {
    765     printing::HttpConnectionCUPS http(url, encryption);
    766     http.SetBlocking(false);
    767     return cupsGetJobs2(http.http(), jobs, name, myjobs, whichjobs);
    768   }
    769 }
    770 
    771 PlatformJobId PrintSystemCUPS::SpoolPrintJob(
    772     const std::string& print_ticket,
    773     const base::FilePath& print_data_file_path,
    774     const std::string& print_data_mime_type,
    775     const std::string& printer_name,
    776     const std::string& job_title,
    777     const std::vector<std::string>& tags,
    778     bool* dry_run) {
    779   DCHECK(initialized_);
    780   VLOG(1) << "CP_CUPS: Spooling print job, printer name: " << printer_name;
    781 
    782   std::string short_printer_name;
    783   PrintServerInfoCUPS* server_info =
    784       FindServerByFullName(printer_name, &short_printer_name);
    785   if (!server_info)
    786     return false;
    787 
    788   crash_keys::ScopedPrinterInfo crash_key(
    789       server_info->backend->GetPrinterDriverInfo(printer_name));
    790 
    791   // We need to store options as char* string for the duration of the
    792   // cupsPrintFile2 call. We'll use map here to store options, since
    793   // Dictionary value from JSON parser returns wchat_t.
    794   std::map<std::string, std::string> options;
    795   bool res = ParsePrintTicket(print_ticket, &options);
    796   DCHECK(res);  // If print ticket is invalid we still print using defaults.
    797 
    798   // Check if this is a dry run (test) job.
    799   *dry_run = IsDryRunJob(tags);
    800   if (*dry_run) {
    801     VLOG(1) << "CP_CUPS: Dry run job spooled";
    802     return kDryRunJobId;
    803   }
    804 
    805   std::vector<cups_option_t> cups_options;
    806   std::map<std::string, std::string>::iterator it;
    807 
    808   for (it = options.begin(); it != options.end(); ++it) {
    809     cups_option_t opt;
    810     opt.name = const_cast<char*>(it->first.c_str());
    811     opt.value = const_cast<char*>(it->second.c_str());
    812     cups_options.push_back(opt);
    813   }
    814 
    815   int job_id = PrintFile(server_info->url,
    816                          cups_encryption_,
    817                          short_printer_name.c_str(),
    818                          print_data_file_path.value().c_str(),
    819                          job_title.c_str(),
    820                          cups_options.size(),
    821                          &(cups_options[0]));
    822 
    823   // TODO(alexyu): Output printer id.
    824   VLOG(1) << "CP_CUPS: Job spooled"
    825           << ", printer name: " << printer_name
    826           << ", cups job id: " << job_id;
    827 
    828   return job_id;
    829 }
    830 
    831 std::string PrintSystemCUPS::MakeFullPrinterName(
    832     const GURL& url, const std::string& short_printer_name) {
    833   std::string full_name;
    834   full_name += "\\\\";
    835   full_name += url.host();
    836   if (!url.port().empty()) {
    837     full_name += ":";
    838     full_name += url.port();
    839   }
    840   full_name += "\\";
    841   full_name += short_printer_name;
    842   return full_name;
    843 }
    844 
    845 PrintServerInfoCUPS* PrintSystemCUPS::FindServerByFullName(
    846     const std::string& full_printer_name, std::string* short_printer_name) {
    847   size_t front = full_printer_name.find("\\\\");
    848   size_t separator = full_printer_name.find("\\", 2);
    849   if (front == std::string::npos || separator == std::string::npos) {
    850     LOG(WARNING) << "CP_CUPS: Invalid UNC"
    851                  << ", printer name: " << full_printer_name;
    852     return NULL;
    853   }
    854   std::string server = full_printer_name.substr(2, separator - 2);
    855 
    856   PrintServerList::iterator it;
    857   for (it = print_servers_.begin(); it != print_servers_.end(); ++it) {
    858     std::string cur_server;
    859     cur_server += it->url.host();
    860     if (!it->url.port().empty()) {
    861       cur_server += ":";
    862       cur_server += it->url.port();
    863     }
    864     if (cur_server == server) {
    865       *short_printer_name = full_printer_name.substr(separator + 1);
    866       return &(*it);
    867     }
    868   }
    869 
    870   LOG(WARNING) << "CP_CUPS: Server not found"
    871                << ", printer name: " << full_printer_name;
    872   return NULL;
    873 }
    874 
    875 void PrintSystemCUPS::RunCapsCallback(
    876     const PrinterCapsAndDefaultsCallback& callback,
    877     bool succeeded,
    878     const std::string& printer_name,
    879     const printing::PrinterCapsAndDefaults& printer_info) {
    880   callback.Run(succeeded, printer_name, printer_info);
    881 }
    882 
    883 }  // namespace cloud_print
    884