// Copyright 2016 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 "printing/backend/cups_connection.h" #include #include #include #include #include #include "base/logging.h" #include "build/build_config.h" #include "printing/backend/cups_helper.h" #include "printing/backend/cups_jobs.h" #if BUILDFLAG(IS_CHROMEOS) #include "printing/backend/cups_connection_pool.h" #endif namespace printing { namespace { // The number of jobs we'll retrieve for a queue. We expect a user to queue at // most 10 jobs per printer. If they queue more, they won't receive updates for // the 11th job until one finishes. constexpr int kProcessingJobsLimit = 10; // The number of completed jobs that are retrieved. We only need one update for // a completed job to confirm its final status. We could retrieve one but we // retrieve the last 3 in case that many finished between queries. constexpr int kCompletedJobsLimit = 3; class DestinationEnumerator { public: DestinationEnumerator() {} DestinationEnumerator(const DestinationEnumerator&) = delete; DestinationEnumerator& operator=(const DestinationEnumerator&) = delete; static int cups_callback(void* user_data, unsigned flags, cups_dest_t* dest) { cups_dest_t* copied_dest; cupsCopyDest(dest, 0, &copied_dest); reinterpret_cast(user_data)->store_dest( copied_dest); // keep going return 1; } void store_dest(cups_dest_t* dest) { dests_.emplace_back(dest); } // Returns the collected destinations. std::vector& get_dests() { return dests_; } private: std::vector dests_; }; } // namespace QueueStatus::QueueStatus() = default; QueueStatus::QueueStatus(const QueueStatus& other) = default; QueueStatus::~QueueStatus() = default; class CupsConnectionImpl : public CupsConnection { public: CupsConnectionImpl(const GURL& print_server_url, http_encryption_t encryption, bool blocking) : print_server_url_(print_server_url), cups_encryption_(encryption), blocking_(false), cups_http_(nullptr) {} CupsConnectionImpl(CupsConnectionImpl&& connection) : print_server_url_(connection.print_server_url_), cups_encryption_(connection.cups_encryption_), blocking_(connection.blocking_), cups_http_(std::move(connection.cups_http_)) {} ~CupsConnectionImpl() override { #if BUILDFLAG(IS_CHROMEOS) if (cups_http_) { // If there is a connection pool, then the connection we have came from // it. We must add the connection back to the pool for possible reuse // rather than letting it be automatically closed, since we can never get // it back after closing it. CupsConnectionPool* connection_pool = CupsConnectionPool::GetInstance(); if (connection_pool) connection_pool->AddConnection(std::move(cups_http_)); } #endif // BUILDFLAG(IS_CHROMEOS) } bool GetDests(std::vector>& printers) override { printers.clear(); if (!Connect()) { LOG(WARNING) << "CUPS connection failed: "; return false; } DestinationEnumerator enumerator; const int success = cupsEnumDests(CUPS_DEST_FLAGS_NONE, kCupsTimeoutMs, /*cancel=*/nullptr, /*type=*/CUPS_PRINTER_LOCAL, kDestinationsFilterMask, &DestinationEnumerator::cups_callback, &enumerator); if (!success) { LOG(WARNING) << "Enumerating printers failed"; return false; } auto dests = std::move(enumerator.get_dests()); for (auto& dest : dests) { printers.push_back( CupsPrinter::Create(cups_http_.get(), std::move(dest))); } return true; } std::unique_ptr GetPrinter(const std::string& name) override { if (!Connect()) return nullptr; cups_dest_t* dest = cupsGetNamedDest(cups_http_.get(), name.c_str(), nullptr); if (!dest) return nullptr; return CupsPrinter::Create(cups_http_.get(), ScopedDestination(dest)); } bool GetJobs(const std::vector& printer_ids, std::vector* queues) override { DCHECK(queues); if (!Connect()) { LOG(ERROR) << "Could not establish connection to CUPS"; return false; } std::vector temp_queues; for (const std::string& id : printer_ids) { temp_queues.emplace_back(); QueueStatus* queue_status = &temp_queues.back(); if (!printing::GetPrinterStatus(cups_http_.get(), id, &queue_status->printer_status)) { LOG(WARNING) << "Could not retrieve printer status for " << id; return false; } if (!GetCupsJobs(cups_http_.get(), id, kCompletedJobsLimit, COMPLETED, &queue_status->jobs)) { LOG(WARNING) << "Could not get completed jobs for " << id; return false; } if (!GetCupsJobs(cups_http_.get(), id, kProcessingJobsLimit, PROCESSING, &queue_status->jobs)) { LOG(WARNING) << "Could not get in progress jobs for " << id; return false; } } queues->insert(queues->end(), temp_queues.begin(), temp_queues.end()); return true; } bool GetPrinterStatus(const std::string& printer_id, PrinterStatus* printer_status) override { if (!Connect()) { LOG(ERROR) << "Could not establish connection to CUPS"; return false; } return printing::GetPrinterStatus(cups_http_.get(), printer_id, printer_status); } std::string server_name() const override { return print_server_url_.host(); } int last_error() const override { return cupsLastError(); } std::string last_error_message() const override { return cupsLastErrorString(); } private: // lazily initialize http connection bool Connect() { if (cups_http_) return true; // we're already connected #if BUILDFLAG(IS_CHROMEOS) // If a connection pool has been created for this process then we must // allocate a connection from that, and not try to create a new one now. CupsConnectionPool* connection_pool = CupsConnectionPool::GetInstance(); if (connection_pool) { cups_http_ = connection_pool->TakeConnection(); if (!cups_http_) LOG(WARNING) << "No available connections in the CUPS connection pool"; return !!cups_http_; } #endif // BUILDFLAG(IS_CHROMEOS) std::string host; int port; if (!print_server_url_.is_empty()) { host = print_server_url_.host(); port = print_server_url_.IntPort(); } else { host = cupsServer(); port = ippPort(); } cups_http_.reset(httpConnect2(host.c_str(), port, nullptr, AF_UNSPEC, cups_encryption_, blocking_ ? 1 : 0, kCupsTimeoutMs, nullptr)); return !!cups_http_; } GURL print_server_url_; http_encryption_t cups_encryption_; bool blocking_; ScopedHttpPtr cups_http_; }; std::unique_ptr CupsConnection::Create( const GURL& print_server_url, http_encryption_t encryption, bool blocking) { return std::make_unique(print_server_url, encryption, blocking); } } // namespace printing