Adding functionality to specify TLS encryption CUPS print servers for cloudprint connector.

chrome/service/cloud_print/print_system_cups.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/service/cloud_print/print_system.h"
 
 #include <cups/cups.h>
 #include <dlfcn.h>
 #include <errno.h>
 #include <pthread.h>
@@ skipping 115 matching lines @@
     return notify_delete_ && printer_enum_succeeded_;
   }
 
  private:
   virtual ~PrintSystemCUPS() {}
 
   // Following functions are wrappers around corresponding CUPS functions.
   // <functions>2()  are called when print server is specified, and plain
   // version in another case. There is an issue specifing CUPS_HTTP_DEFAULT
   // in the <functions>2(), it does not work in CUPS prior to 1.4.
-  int GetJobs(cups_job_t** jobs, const GURL& url, const char* name,
+  int GetJobs(cups_job_t** jobs, const GURL& url,
+              http_encryption_t encryption, const char* name,
               int myjobs, int whichjobs);
-  int PrintFile(const GURL& url, const char* name, const char* filename,
+  int PrintFile(const GURL& url, http_encryption_t encryption,
+                const char* name, const char* filename,
                 const char* title, int num_options, cups_option_t* options);

[Ryan Sleevi, 2012/05/17 00:35:27]

nit: these too

 
   void InitPrintBackends(const DictionaryValue* print_system_settings);
   void AddPrintServer(const std::string& url);
 
   void UpdatePrinters();
 
   // Full name contains print server url:port and printer name. Short name
   // is the name of the printer in the CUPS server.
   std::string MakeFullPrinterName(const GURL& url,
                                   const std::string& short_printer_name);
   PrintServerInfoCUPS* FindServerByFullName(
       const std::string& full_printer_name, std::string* short_printer_name);
 
   // Helper method to invoke a PrinterCapsAndDefaultsCallback.
   static void RunCapsCallback(
       const PrinterCapsAndDefaultsCallback& callback,
       bool succeeded,
       const std::string& printer_name,
       const printing::PrinterCapsAndDefaults& printer_info);
 
   // PrintServerList contains information about all print servers and backends
   // this proxy is connected to.
   typedef std::list<PrintServerInfoCUPS> PrintServerList;
   PrintServerList print_servers_;
 
   base::TimeDelta update_timeout_;
   bool initialized_;
   bool printer_enum_succeeded_;
   bool notify_delete_;
+  http_encryption_t cups_encryption_;
 };
 
 class PrintServerWatcherCUPS
   : public PrintSystem::PrintServerWatcher {
  public:
   explicit PrintServerWatcherCUPS(PrintSystemCUPS* print_system)
       : print_system_(print_system),
         delegate_(NULL) {
   }
 
@@ skipping 220 matching lines @@
   scoped_refptr<PrintSystemCUPS> print_system_;
 
   DISALLOW_COPY_AND_ASSIGN(JobSpoolerCUPS);
 };
 
 PrintSystemCUPS::PrintSystemCUPS(const DictionaryValue* print_system_settings)
     : update_timeout_(base::TimeDelta::FromMinutes(
         kCheckForPrinterUpdatesMinutes)),
       initialized_(false),
       printer_enum_succeeded_(false),
-      notify_delete_(true) {
+      notify_delete_(true),
+      cups_encryption_(HTTP_ENCRYPT_NEVER) {
   if (print_system_settings) {
     int timeout;
     if (print_system_settings->GetInteger(kCUPSUpdateTimeoutMs, &timeout))
       update_timeout_ = base::TimeDelta::FromMilliseconds(timeout);
 
+    int encryption;
+    if (print_system_settings->GetInteger(kCUPSEncryption, &encryption))
+      cups_encryption_ =
+          static_cast<http_encryption_t>(encryption);
+
     bool notify_delete = true;
     if (print_system_settings->GetBoolean(kCUPSNotifyDelete, &notify_delete))
       notify_delete_ = notify_delete;
   }
 
   InitPrintBackends(print_system_settings);
 }
 
 void PrintSystemCUPS::InitPrintBackends(
     const DictionaryValue* print_system_settings) {
@@ skipping 16 matching lines @@
   if (url.empty())
     LOG(WARNING) << "No print server specified. Using default print server.";
 
   // Get Print backend for the specific print server.
   DictionaryValue backend_settings;
   backend_settings.SetString(kCUPSPrintServerURL, url);
 
   // Make CUPS requests non-blocking.
   backend_settings.SetString(kCUPSBlocking, kValueFalse);
 
+  // Set encryption for backend.
+  backend_settings.SetInteger(kCUPSEncryption, cups_encryption_);
+
   PrintServerInfoCUPS print_server;
   print_server.backend =
     printing::PrintBackend::CreateInstance(&backend_settings);
   print_server.url = GURL(url.c_str());
 
   print_servers_.push_back(print_server);
 }
 
 PrintSystem::PrintSystemResult PrintSystemCUPS::Init() {
   UpdatePrinters();
@@ skipping 122 matching lines @@
 
   std::string short_printer_name;
   PrintServerInfoCUPS* server_info =
       FindServerByFullName(printer_name, &short_printer_name);
   if (!server_info)
     return false;
 
   child_process_logging::ScopedPrinterInfoSetter prn_info(
       server_info->backend->GetPrinterDriverInfo(short_printer_name));
   cups_job_t* jobs = NULL;
-  int num_jobs = GetJobs(&jobs, server_info->url,
+  int num_jobs = GetJobs(&jobs, server_info->url, cups_encryption_,
                          short_printer_name.c_str(), 1, -1);
   bool error = (num_jobs == 0) && (cupsLastError() > IPP_OK_EVENTS_COMPLETE);
   if (error) {
     VLOG(1) << "CP_CUPS: Error getting jobs from CUPS server. Printer:"
             << printer_name
             << " Error: "
             << static_cast<int>(cupsLastError());
     return false;
   }
 
@@ skipping 102 matching lines @@
   std::string id("CP_PROXY_");
   id += base::Uint64ToString(base::RandUint64());
   return id;
 }
 
 scoped_refptr<PrintSystem> PrintSystem::CreateInstance(
     const DictionaryValue* print_system_settings) {
   return new PrintSystemCUPS(print_system_settings);
 }
 
-int PrintSystemCUPS::PrintFile(const GURL& url, const char* name,
-                               const char* filename, const char* title,
-                               int num_options, cups_option_t* options) {
+int PrintSystemCUPS::PrintFile(const GURL& url, http_encryption_t encryption,
+                               const char* name, const char* filename,
+                               const char* title, int num_options,
+                               cups_option_t* options) {
   if (url.is_empty()) {  // Use default (local) print server.
     return cupsPrintFile(name, filename, title, num_options, options);
   } else {
-    printing::HttpConnectionCUPS http(url);
+    printing::HttpConnectionCUPS http(url, encryption);
     http.SetBlocking(false);
     return cupsPrintFile2(http.http(), name, filename,
                           title, num_options, options);
   }
 }
 
 int PrintSystemCUPS::GetJobs(cups_job_t** jobs, const GURL& url,
+                             http_encryption_t encryption,
                              const char* name, int myjobs, int whichjobs) {
   if (url.is_empty()) {  // Use default (local) print server.
     return cupsGetJobs(jobs, name, myjobs, whichjobs);
   } else {
-    printing::HttpConnectionCUPS http(url);
+    printing::HttpConnectionCUPS http(url, encryption);
     http.SetBlocking(false);
     return cupsGetJobs2(http.http(), jobs, name, myjobs, whichjobs);
   }
 }
 
 PlatformJobId PrintSystemCUPS::SpoolPrintJob(
     const std::string& print_ticket,
     const FilePath& print_data_file_path,
     const std::string& print_data_mime_type,
     const std::string& printer_name,
@@ skipping 30 matching lines @@
   std::map<std::string, std::string>::iterator it;
 
   for (it = options.begin(); it != options.end(); ++it) {
     cups_option_t opt;
     opt.name = const_cast<char*>(it->first.c_str());
     opt.value = const_cast<char*>(it->second.c_str());
     cups_options.push_back(opt);
   }
 
   int job_id = PrintFile(server_info->url,
+                         cups_encryption_,
                          short_printer_name.c_str(),
                          print_data_file_path.value().c_str(),
                          job_title.c_str(),
                          cups_options.size(),
                          &(cups_options[0]));
 
   VLOG(1) << "CP_CUPS: Job spooled, id: " << job_id;
 
   return job_id;
 }
@@ skipping 42 matching lines @@
 
 void PrintSystemCUPS::RunCapsCallback(
     const PrinterCapsAndDefaultsCallback& callback,
     bool succeeded,
     const std::string& printer_name,
     const printing::PrinterCapsAndDefaults& printer_info) {
   callback.Run(succeeded, printer_name, printer_info);
 }
 
 }  // namespace cloud_print