chrome/browser/ash/printing/server_printers_fetcher.cc - chromium/src - Git at Google

 // Copyright 2019 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "chrome/browser/ash/printing/server_printers_fetcher.h"

 #include <string>
 #include <string_view>
 #include <utility>

 #include "base/logging.h"
 #include "base/memory/raw_ptr.h"
 #include "base/memory/scoped_refptr.h"
 #include "base/sequence_checker.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/task/sequenced_task_runner.h"
 #include "base/task/task_traits.h"
 #include "base/task/thread_pool.h"
 #include "chrome/browser/net/system_network_context_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "components/device_event_log/device_event_log.h"
 #include "crypto/obsolete/md5.h"
 #include "net/base/load_flags.h"
 #include "net/traffic_annotation/network_traffic_annotation.h"
 #include "services/network/public/cpp/resource_request.h"
 #include "services/network/public/cpp/shared_url_loader_factory.h"
 #include "services/network/public/cpp/simple_url_loader.h"
 #include "services/network/public/cpp/simple_url_loader_stream_consumer.h"
 #include "third_party/libipp/libipp/builder.h"
 #include "third_party/libipp/libipp/frame.h"
 #include "third_party/libipp/libipp/parser.h"
 #include "url/gurl.h"

 namespace ash {

 namespace printing {

 // Not in namespace {} so it can be friended by crypto/obsolete/md5.
 std::string ServerPrinterId(const std::string& url) {
   return "server-" +
          base::ToLowerASCII(base::HexEncode(crypto::obsolete::Md5::Hash(url)));
 }

 }  // namespace printing

 namespace {

 constexpr net::NetworkTrafficAnnotationTag kServerPrintersFetcherNetworkTag =
     net::DefineNetworkTrafficAnnotation("printing_server_printers_query", R"(
     semantics {
       sender: "ChromeOS Printers Manager"
       description:
         "Fetches the list of available printers from the Print Server."
       trigger: "1. User asked for the list of available printers from "
                "a chosen Print Server."
                "2. ChromeOS automatically queries printers from Print "
                "Servers whose addresses are set by the organization's "
                "administrator at the Google admin console."
       data: "None."
       destination: OTHER
       destination_other: "Print Server"
     }
     policy {
       cookies_allowed: NO
       setting:
         "This feature is enabled as long as printing is enabled."
       chrome_policy {
         PrintingEnabled {
             PrintingEnabled: false
         }
       }
     })");

 }  // namespace

 class ServerPrintersFetcher::PrivateImplementation
     : public network::SimpleURLLoaderStreamConsumer {
  public:
   PrivateImplementation(const ServerPrintersFetcher* owner,
                         Profile* profile,
                         const GURL& server_url,
                         const std::string& server_name,
                         ServerPrintersFetcher::OnPrintersFetchedCallback cb)
       : owner_(owner),
         server_url_(server_url),
         server_name_(server_name),
         callback_(std::move(cb)),
         task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
             {base::TaskShutdownBehavior::BLOCK_SHUTDOWN})) {
     DETACH_FROM_SEQUENCE(sequence_checker_);
     CHECK(base::SequencedTaskRunner::HasCurrentDefault());
     task_runner_for_callback_ = base::SequencedTaskRunner::GetCurrentDefault();
     // Post task to execute.
     task_runner_->PostTask(
         FROM_HERE, base::BindOnce(&PrivateImplementation::SendQuery,
                                   base::Unretained(this),
                                   profile->GetURLLoaderFactory()->Clone()));
   }

   PrivateImplementation(const PrivateImplementation&) = delete;
   PrivateImplementation& operator=(const PrivateImplementation&) = delete;

   ~PrivateImplementation() override = default;

   // Schedule the given object for deletion. May be called from any
   // sequence/thread.
   void Delete() { task_runner_->DeleteSoon(FROM_HERE, this); }

   // Implementation of network::SimpleURLLoaderStreamConsumer.
   void OnDataReceived(std::string_view part_of_payload,
                       base::OnceClosure resume) override {
     DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     response_.insert(response_.end(), part_of_payload.begin(),
                      part_of_payload.end());
     std::move(resume).Run();
   }

   // Implementation of network::SimpleURLLoaderStreamConsumer.
   void OnComplete(bool success) override {
     DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     if (!success) {
       const int net_error = simple_url_loader_->NetError();
       PRINTER_LOG(ERROR) << "Error when querying the print server "
                          << server_name_ << ": NetError=" << net_error;
       // Set last_error_, call the callback with an empty vector and exit.
       if (net_error >= -399 && net_error <= -303) {
         last_error_ = PrintServerQueryResult::kHttpError;
       } else if (net_error >= -302 && net_error <= -300) {
         last_error_ = PrintServerQueryResult::kIncorrectUrl;
       } else {
         last_error_ = PrintServerQueryResult::kConnectionError;
       }
       PostResponse({});
       return;
     }
     // Try to parse the response.
     ipp::SimpleParserLog log;
     ipp::Frame response = ipp::Parse(response_.data(), response_.size(), log);
     if (!log.Errors().empty()) {
       // Errors were detected during parsing.
       std::string message =
           "Errors detected when parsing a response from the "
           "print server " +
           server_name_ + ". Parser log:";
       for (const auto& entry : log.Errors()) {
         message += "\n * " + ipp::ToString(entry);
       }
       LOG(WARNING) << message;
     }
     if (!log.CriticalErrors().empty()) {
       // Parser has failed. Dump errors to the log.
       std::string message = "Cannot parse response from the print server " +
                             server_name_ + ". Critical errors:";
       for (const auto& entry : log.CriticalErrors()) {
         message += "\n * " + ipp::ToString(entry);
       }
       LOG(WARNING) << message;
       PRINTER_LOG(ERROR) << "Error when querying the print server "
                          << server_name_ << ": unparsable IPP response.";
       // Set last_error_, call the callback with an empty vector and exit.
       last_error_ = PrintServerQueryResult::kCannotParseIppResponse;
       PostResponse({});
       return;
     }
     // The response parsed successfully. Retrieve the list of printers.
     ipp::CollsView printer_attrs =
         response.Groups(ipp::GroupTag::printer_attributes);
     std::vector<PrinterDetector::DetectedPrinter> printers(
         printer_attrs.size());
     for (size_t i = 0; i < printers.size(); ++i) {
       ipp::Collection::iterator it = printer_attrs[i].GetAttr("printer-name");
       ipp::StringWithLanguage name;
       if (it == printer_attrs[i].end() ||
           it->GetValue(0, name) != ipp::Code::kOK) {
         name.value = "Unknown Printer " + base::NumberToString(i);
       }
       InitializePrinter(&(printers[i].printer), name.value);
     }
     // Call the callback with queried printers.
     PRINTER_LOG(DEBUG) << "The print server " << server_name_ << " returned "
                        << printers.size() << " printer"
                        << (printers.size() == 1 ? "." : "s.");
     PostResponse(std::move(printers));
   }

   // Implementation of network::SimpleURLLoaderStreamConsumer.
   void OnRetry(base::OnceClosure start_retry) override {
     DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     response_.clear();
     std::move(start_retry).Run();
   }

   PrintServerQueryResult last_error() const { return last_error_; }

  private:
   // The main task. It is scheduled in the constructor.
   void SendQuery(std::unique_ptr<network::PendingSharedURLLoaderFactory>
                      url_loader_factory) {
     DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

     // Preparation of the IPP frame.
     ipp::Frame request(ipp::Operation::CUPS_Get_Printers);
     DCHECK_EQ(ipp::Code::kOK,
               request.Groups(ipp::GroupTag::operation_attributes)[0].AddAttr(
                   "requested-attributes", ipp::ValueTag::keyword,
                   "printer-description"));
     std::vector<uint8_t> request_frame = ipp::BuildBinaryFrame(request);

     // Send request.
     auto resource_request = std::make_unique<network::ResourceRequest>();
     resource_request->url = server_url_;
     resource_request->method = "POST";
     resource_request->load_flags =
         net::LOAD_BYPASS_CACHE | net::LOAD_DISABLE_CACHE;
     resource_request->credentials_mode = network::mojom::CredentialsMode::kOmit;
     // TODO(pawliczek): create a traffic annotation for printing network traffic
     simple_url_loader_ = network::SimpleURLLoader::Create(
         std::move(resource_request), kServerPrintersFetcherNetworkTag);
     std::string request_body(request_frame.begin(), request_frame.end());
     simple_url_loader_->AttachStringForUpload(request_body, "application/ipp");
     simple_url_loader_->DownloadAsStream(
         network::SharedURLLoaderFactory::Create(std::move(url_loader_factory))
             .get(),
         this);
   }

   // Posts a response with a list of printers.
   void PostResponse(std::vector<PrinterDetector::DetectedPrinter>&& printers) {
     task_runner_for_callback_->PostNonNestableTask(
         FROM_HERE, base::BindOnce(callback_, owner_, server_url_, printers));
   }

   // Set an object |printer| to represent a server printer with a name |name|.
   // The printer is provided by the current print server.
   void InitializePrinter(chromeos::Printer* printer, const std::string& name) {
     // All server printers are configured with IPP Everywhere.
     printer->mutable_ppd_reference()->autoconf = true;

     // As a display name we use the name fetched from the print server.
     printer->set_display_name(name);

     // Build printer's URL: we have to convert http/https to ipp/ipps because
     // some third-party components require ipp schema. E.g.:
     // * http://myprinter:123/abc =>  ipp://myprinter:123/abc
     // * http://myprinter/abc     =>  ipp://myprinter:80/abc
     // * https://myprinter/abc    =>  ipps://myprinter:443/abc
     chromeos::Uri url;
     if (server_url_.SchemeIs("https")) {
       url.SetScheme("ipps");
     } else {
       url.SetScheme("ipp");
     }
     url.SetHostEncoded(server_url_.HostNoBrackets());
     url.SetPort(server_url_.EffectiveIntPort());
     // Save the server URI.
     printer->set_print_server_uri(url.GetNormalized());
     // Complete building the printer's URI.
     url.SetPath({"printers", name});
     printer->SetUri(url);
     printer->set_id(printing::ServerPrinterId(url.GetNormalized()));
   }

   raw_ptr<const ServerPrintersFetcher, DanglingUntriaged> owner_;
   const GURL server_url_;
   const std::string server_name_;

   scoped_refptr<base::SequencedTaskRunner> task_runner_for_callback_;
   ServerPrintersFetcher::OnPrintersFetchedCallback callback_;

   // Raw payload of the HTTP response.
   std::vector<uint8_t> response_;

   PrintServerQueryResult last_error_ = PrintServerQueryResult::kNoErrors;

   scoped_refptr<base::SequencedTaskRunner> task_runner_;

   std::unique_ptr<network::SimpleURLLoader> simple_url_loader_;
   SEQUENCE_CHECKER(sequence_checker_);
 };

 ServerPrintersFetcher::ServerPrintersFetcher(Profile* profile,
                                              const GURL& server_url,
                                              const std::string& server_name,
                                              OnPrintersFetchedCallback cb)
     : pim_(new PrivateImplementation(this,
                                      profile,
                                      server_url,
                                      server_name,
                                      std::move(cb)),
            PimDeleter()) {}

 void ServerPrintersFetcher::PimDeleter::operator()(
     PrivateImplementation* pim) const {
   pim->Delete();
 }

 ServerPrintersFetcher::~ServerPrintersFetcher() = default;

 PrintServerQueryResult ServerPrintersFetcher::GetLastError() const {
   return pim_->last_error();
 }

 }  // namespace ash
	// Copyright 2019 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "chrome/browser/ash/printing/server_printers_fetcher.h"

	#include <string>
	#include <string_view>
	#include <utility>

	#include "base/logging.h"
	#include "base/memory/raw_ptr.h"
	#include "base/memory/scoped_refptr.h"
	#include "base/sequence_checker.h"
	#include "base/strings/string_number_conversions.h"
	#include "base/strings/string_util.h"
	#include "base/task/sequenced_task_runner.h"
	#include "base/task/task_traits.h"
	#include "base/task/thread_pool.h"
	#include "chrome/browser/net/system_network_context_manager.h"
	#include "chrome/browser/profiles/profile.h"
	#include "components/device_event_log/device_event_log.h"
	#include "crypto/obsolete/md5.h"
	#include "net/base/load_flags.h"
	#include "net/traffic_annotation/network_traffic_annotation.h"
	#include "services/network/public/cpp/resource_request.h"
	#include "services/network/public/cpp/shared_url_loader_factory.h"
	#include "services/network/public/cpp/simple_url_loader.h"
	#include "services/network/public/cpp/simple_url_loader_stream_consumer.h"
	#include "third_party/libipp/libipp/builder.h"
	#include "third_party/libipp/libipp/frame.h"
	#include "third_party/libipp/libipp/parser.h"
	#include "url/gurl.h"

	namespace ash {

	namespace printing {

	// Not in namespace {} so it can be friended by crypto/obsolete/md5.
	std::string ServerPrinterId(const std::string& url) {
	return "server-" +
	base::ToLowerASCII(base::HexEncode(crypto::obsolete::Md5::Hash(url)));
	}

	} // namespace printing

	namespace {

	constexpr net::NetworkTrafficAnnotationTag kServerPrintersFetcherNetworkTag =
	net::DefineNetworkTrafficAnnotation("printing_server_printers_query", R"(
	semantics {
	sender: "ChromeOS Printers Manager"
	description:
	"Fetches the list of available printers from the Print Server."
	trigger: "1. User asked for the list of available printers from "
	"a chosen Print Server."
	"2. ChromeOS automatically queries printers from Print "
	"Servers whose addresses are set by the organization's "
	"administrator at the Google admin console."
	data: "None."
	destination: OTHER
	destination_other: "Print Server"
	}
	policy {
	cookies_allowed: NO
	setting:
	"This feature is enabled as long as printing is enabled."
	chrome_policy {
	PrintingEnabled {
	PrintingEnabled: false
	}
	}
	})");

	} // namespace

	class ServerPrintersFetcher::PrivateImplementation
	: public network::SimpleURLLoaderStreamConsumer {
	public:
	PrivateImplementation(const ServerPrintersFetcher* owner,
	Profile* profile,
	const GURL& server_url,
	const std::string& server_name,
	ServerPrintersFetcher::OnPrintersFetchedCallback cb)
	: owner_(owner),
	server_url_(server_url),
	server_name_(server_name),
	callback_(std::move(cb)),
	task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
	{base::TaskShutdownBehavior::BLOCK_SHUTDOWN})) {
	DETACH_FROM_SEQUENCE(sequence_checker_);
	CHECK(base::SequencedTaskRunner::HasCurrentDefault());
	task_runner_for_callback_ = base::SequencedTaskRunner::GetCurrentDefault();
	// Post task to execute.
	task_runner_->PostTask(
	FROM_HERE, base::BindOnce(&PrivateImplementation::SendQuery,
	base::Unretained(this),
	profile->GetURLLoaderFactory()->Clone()));
	}

	PrivateImplementation(const PrivateImplementation&) = delete;
	PrivateImplementation& operator=(const PrivateImplementation&) = delete;

	~PrivateImplementation() override = default;

	// Schedule the given object for deletion. May be called from any
	// sequence/thread.
	void Delete() { task_runner_->DeleteSoon(FROM_HERE, this); }

	// Implementation of network::SimpleURLLoaderStreamConsumer.
	void OnDataReceived(std::string_view part_of_payload,
	base::OnceClosure resume) override {
	DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
	response_.insert(response_.end(), part_of_payload.begin(),
	part_of_payload.end());
	std::move(resume).Run();
	}

	// Implementation of network::SimpleURLLoaderStreamConsumer.
	void OnComplete(bool success) override {
	DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
	if (!success) {
	const int net_error = simple_url_loader_->NetError();
	PRINTER_LOG(ERROR) << "Error when querying the print server "
	<< server_name_ << ": NetError=" << net_error;
	// Set last_error_, call the callback with an empty vector and exit.
	if (net_error >= -399 && net_error <= -303) {
	last_error_ = PrintServerQueryResult::kHttpError;
	} else if (net_error >= -302 && net_error <= -300) {
	last_error_ = PrintServerQueryResult::kIncorrectUrl;
	} else {
	last_error_ = PrintServerQueryResult::kConnectionError;
	}
	PostResponse({});
	return;
	}
	// Try to parse the response.
	ipp::SimpleParserLog log;
	ipp::Frame response = ipp::Parse(response_.data(), response_.size(), log);
	if (!log.Errors().empty()) {
	// Errors were detected during parsing.
	std::string message =
	"Errors detected when parsing a response from the "
	"print server " +
	server_name_ + ". Parser log:";
	for (const auto& entry : log.Errors()) {
	message += "\n * " + ipp::ToString(entry);
	}
	LOG(WARNING) << message;
	}
	if (!log.CriticalErrors().empty()) {
	// Parser has failed. Dump errors to the log.
	std::string message = "Cannot parse response from the print server " +
	server_name_ + ". Critical errors:";
	for (const auto& entry : log.CriticalErrors()) {
	message += "\n * " + ipp::ToString(entry);
	}
	LOG(WARNING) << message;
	PRINTER_LOG(ERROR) << "Error when querying the print server "
	<< server_name_ << ": unparsable IPP response.";
	// Set last_error_, call the callback with an empty vector and exit.
	last_error_ = PrintServerQueryResult::kCannotParseIppResponse;
	PostResponse({});
	return;
	}
	// The response parsed successfully. Retrieve the list of printers.
	ipp::CollsView printer_attrs =
	response.Groups(ipp::GroupTag::printer_attributes);
	std::vector<PrinterDetector::DetectedPrinter> printers(
	printer_attrs.size());
	for (size_t i = 0; i < printers.size(); ++i) {
	ipp::Collection::iterator it = printer_attrs[i].GetAttr("printer-name");
	ipp::StringWithLanguage name;
	if (it == printer_attrs[i].end() \|\|
	it->GetValue(0, name) != ipp::Code::kOK) {
	name.value = "Unknown Printer " + base::NumberToString(i);
	}
	InitializePrinter(&(printers[i].printer), name.value);
	}
	// Call the callback with queried printers.
	PRINTER_LOG(DEBUG) << "The print server " << server_name_ << " returned "
	<< printers.size() << " printer"
	<< (printers.size() == 1 ? "." : "s.");
	PostResponse(std::move(printers));
	}

	// Implementation of network::SimpleURLLoaderStreamConsumer.
	void OnRetry(base::OnceClosure start_retry) override {
	DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
	response_.clear();
	std::move(start_retry).Run();
	}

	PrintServerQueryResult last_error() const { return last_error_; }

	private:
	// The main task. It is scheduled in the constructor.
	void SendQuery(std::unique_ptr<network::PendingSharedURLLoaderFactory>
	url_loader_factory) {
	DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

	// Preparation of the IPP frame.
	ipp::Frame request(ipp::Operation::CUPS_Get_Printers);
	DCHECK_EQ(ipp::Code::kOK,
	request.Groups(ipp::GroupTag::operation_attributes)[0].AddAttr(
	"requested-attributes", ipp::ValueTag::keyword,
	"printer-description"));
	std::vector<uint8_t> request_frame = ipp::BuildBinaryFrame(request);

	// Send request.
	auto resource_request = std::make_unique<network::ResourceRequest>();
	resource_request->url = server_url_;
	resource_request->method = "POST";
	resource_request->load_flags =
	net::LOAD_BYPASS_CACHE \| net::LOAD_DISABLE_CACHE;
	resource_request->credentials_mode = network::mojom::CredentialsMode::kOmit;
	// TODO(pawliczek): create a traffic annotation for printing network traffic
	simple_url_loader_ = network::SimpleURLLoader::Create(
	std::move(resource_request), kServerPrintersFetcherNetworkTag);
	std::string request_body(request_frame.begin(), request_frame.end());
	simple_url_loader_->AttachStringForUpload(request_body, "application/ipp");
	simple_url_loader_->DownloadAsStream(
	network::SharedURLLoaderFactory::Create(std::move(url_loader_factory))
	.get(),
	this);
	}

	// Posts a response with a list of printers.
	void PostResponse(std::vector<PrinterDetector::DetectedPrinter>&& printers) {
	task_runner_for_callback_->PostNonNestableTask(
	FROM_HERE, base::BindOnce(callback_, owner_, server_url_, printers));
	}

	// Set an object \|printer\| to represent a server printer with a name \|name\|.
	// The printer is provided by the current print server.
	void InitializePrinter(chromeos::Printer* printer, const std::string& name) {
	// All server printers are configured with IPP Everywhere.
	printer->mutable_ppd_reference()->autoconf = true;

	// As a display name we use the name fetched from the print server.
	printer->set_display_name(name);

	// Build printer's URL: we have to convert http/https to ipp/ipps because
	// some third-party components require ipp schema. E.g.:
	// * http://myprinter:123/abc => ipp://myprinter:123/abc
	// * http://myprinter/abc => ipp://myprinter:80/abc
	// * https://myprinter/abc => ipps://myprinter:443/abc
	chromeos::Uri url;
	if (server_url_.SchemeIs("https")) {
	url.SetScheme("ipps");
	} else {
	url.SetScheme("ipp");
	}
	url.SetHostEncoded(server_url_.HostNoBrackets());
	url.SetPort(server_url_.EffectiveIntPort());
	// Save the server URI.
	printer->set_print_server_uri(url.GetNormalized());
	// Complete building the printer's URI.
	url.SetPath({"printers", name});
	printer->SetUri(url);
	printer->set_id(printing::ServerPrinterId(url.GetNormalized()));
	}

	raw_ptr<const ServerPrintersFetcher, DanglingUntriaged> owner_;
	const GURL server_url_;
	const std::string server_name_;

	scoped_refptr<base::SequencedTaskRunner> task_runner_for_callback_;
	ServerPrintersFetcher::OnPrintersFetchedCallback callback_;

	// Raw payload of the HTTP response.
	std::vector<uint8_t> response_;

	PrintServerQueryResult last_error_ = PrintServerQueryResult::kNoErrors;

	scoped_refptr<base::SequencedTaskRunner> task_runner_;

	std::unique_ptr<network::SimpleURLLoader> simple_url_loader_;
	SEQUENCE_CHECKER(sequence_checker_);
	};

	ServerPrintersFetcher::ServerPrintersFetcher(Profile* profile,
	const GURL& server_url,
	const std::string& server_name,
	OnPrintersFetchedCallback cb)
	: pim_(new PrivateImplementation(this,
	profile,
	server_url,
	server_name,
	std::move(cb)),
	PimDeleter()) {}

	void ServerPrintersFetcher::PimDeleter::operator()(
	PrivateImplementation* pim) const {
	pim->Delete();
	}

	ServerPrintersFetcher::~ServerPrintersFetcher() = default;

	PrintServerQueryResult ServerPrintersFetcher::GetLastError() const {
	return pim_->last_error();
	}

	} // namespace ash