Add CupsFilter extraction from resolved ppds for printing.

chromeos/printing/ppd_provider.cc

 // 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 "chromeos/printing/ppd_provider.h"
 
 #include <algorithm>
 #include <deque>
+#include <set>
 #include <unordered_map>
 #include <utility>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/bind_helpers.h"
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/json/json_parser.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
+#include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chromeos/printing/ppd_cache.h"
 #include "chromeos/printing/printing_constants.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "url/gurl.h"
 
 namespace chromeos {
 namespace printing {
 namespace {
 
+// Extract cupsFilter/cupsFilter2 filter names from the contents
+// of a ppd, pre-split into lines.
+
+// cupsFilter2 lines look like this:
+//
+// *cupsFilter2: "application/vnd.cups-raster application/vnd.foo 100
+// rastertofoo"
+//
+// cupsFilter lines look like this:
+//
+// *cupsFilter: "application/vnd.cups-raster 100 rastertofoo"
+//
+// |field_name| is the starting token we look for (*cupsFilter: or
+// *cupsFilter2:).
+//
+// |num_mime_types| is the number of mime types we expect to see in the quoted
+// string.
+//
+// This function looks at each line in ppd_lines for lines of this format, and,
+// for each one found, adds the name of the filter (rastertofoo in the examples
+// above) to the returned set.
+//
+// This would be simpler with re2, but re2 is not an allowed dependency in
+// this part of the tree.
+std::set<std::string> ExtractCupsFilters(
+    const std::vector<std::string>& ppd_lines,
+    const std::string& field_name,
+    int num_mime_types) {
+  std::set<std::string> ret;
+  std::string delims(" \n\t\r\"");
+
+  for (const std::string& line : ppd_lines) {
+    base::StringTokenizer line_tok(line, delims);
+
+    if (!line_tok.GetNext()) {
+      continue;
+    }
+    if (line_tok.token_piece() != field_name) {
+      continue;
+    }
+
+    // Skip the mime type(s) and cost, landing on the filter
+    // name.
+    for (int i = 0; i < num_mime_types + 2; ++i) {

[skau, 2017/04/11 16:59:37]

Can you make this slightly less opaque?  Shouldn't it always be the last token
on the line?

[Carlson, 2017/04/11 19:06:49]

Could do, but the tradeoffs are:

* We accept more malformed lines. (We already accept some here)

* We lose some bounding on how much input we process.  If someone for some
reason gives us a PPD consisting of

*cupsFilter2: a a a a a a (x whatever limit we have on filesize) we could spend
potentially a nontrivial amount of time parsing tokens pointlessly.  

Not sure which tradeoff is better here.  For now I just changed num_mime_types
to num_value_tokens, which gets rid of the +2 magic and maybe is a little more
straightforward.  If you want to go straight-up for "grab the last token" I'll
do that instead.

[skau, 2017/04/11 22:14:57]

Thanks for the explanation.  I wasn't thinking of the pathological example. 
Keeping it bounded should be the right choice.  Would we want to run the file
through cupstestppd before trying to read it to make sure it isn't pathological?
 TODO would be fine.

I just realized that StringTokenizer skips consecutive delimiters. Is that
behavior well known (it may just be me)?  If not, leave a comment.

+      if (!line_tok.GetNext()) {
+        // Continue the outer loop.
+        goto next_line;
+      }
+    }
+
+    if (line_tok.token_piece() != "") {
+      ret.insert(line_tok.token_piece().as_string());
+    }
+  next_line : {}  // Lint requires {} instead of ; for an empty statement.
+  }
+  return ret;
+}
+
+// The ppd spec explicitly disallows quotes inside quoted strings, and provides
+// no way for including escaped quotes in a quoted string.  It also requires
+// that the string be a single line, and that everything in these fields be
+// 7-bit ASCII.  The CUPS spec on these particular fields is not particularly
+// rigorous, but specifies no way of including escaped spaces in the tokens
+// themselves, and the cups *code* just parses out these lines with a sscanf
+// call that uses spaces as delimiters.
+//
+// Furthermore, cups (post 1.5) discards all cupsFilter lines if *any*
+// cupsFilter2 lines exist.
+//
+// All of this is a long way of saying the regular-expression based parsing
+// done here is, to the best of my knowledge, actually conformant to the specs
+// that exist, and not just a hack.
+std::vector<std::string> ExtractFiltersFromPpd(
+    const std::string& ppd_contents) {
+  std::vector<std::string> lines = base::SplitString(
+      ppd_contents, "\n\r", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
+  std::set<std::string> filters = ExtractCupsFilters(lines, "*cupsFilter2:", 2);
+  if (filters.empty()) {
+    // No cupsFilter2 lines found, fall back to looking for cupsFilter lines.
+    filters = ExtractCupsFilters(lines, "*cupsFilter:", 1);
+  }
+  return std::vector<std::string>(filters.begin(), filters.end());
+}
+
 // Returns false if there are obvious errors in the reference that will prevent
 // resolution.
 bool PpdReferenceIsWellFormed(const Printer::PpdReference& reference) {
   int filled_fields = 0;
   if (!reference.user_supplied_ppd_url.empty()) {
     ++filled_fields;
     GURL tmp_url(reference.user_supplied_ppd_url);
     if (!tmp_url.is_valid() || !tmp_url.SchemeIs("file")) {
       LOG(ERROR) << "Invalid url for a user-supplied ppd: "
                  << reference.user_supplied_ppd_url
@@ skipping 144 matching lines @@
       auto it = cached_ppd_index_->find(next.first.effective_make_and_model);
       if (it != cached_ppd_index_->end()) {
         StartFetch(GetPpdURL(it->second), FT_PPD);
         return;
       }
       // This ppd reference isn't in the index.  That's not good. Fail
       // out the current resolution and go try to start the next
       // thing if there is one.
       LOG(ERROR) << "PPD " << next.first.effective_make_and_model
                  << " not found in server index";
-      base::SequencedTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE,
-          base::Bind(next.second, PpdProvider::INTERNAL_ERROR, std::string()));
+      FinishPpdResolution(next.second, PpdProvider::INTERNAL_ERROR,
+                          std::string());
       ppd_resolution_queue_.pop_front();
     }
   }
 
   void ResolvePrinters(const std::string& manufacturer,
                        const ResolvePrintersCallback& cb) override {
     std::unordered_map<std::string, ManufacturerMetadata>::iterator it;
     if (cached_metadata_.get() == nullptr ||
         (it = cached_metadata_->find(manufacturer)) ==
             cached_metadata_->end()) {
@@ skipping 47 matching lines @@
     *reference = Printer::PpdReference();
     reference->effective_make_and_model = it2->second;
     return true;
   }
 
   void ResolvePpd(const Printer::PpdReference& reference,
                   const ResolvePpdCallback& cb) override {
     // Do a sanity check here, so we can assumed |reference| is well-formed in
     // the rest of this class.
     if (!PpdReferenceIsWellFormed(reference)) {
-      base::SequencedTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(cb, PpdProvider::INTERNAL_ERROR, ""));
+      FinishPpdResolution(cb, PpdProvider::INTERNAL_ERROR, std::string());
       return;
     }
     // First step, check the cache.  If the cache lookup fails, we'll (try to)
     // consult the server.
     ppd_cache_->Find(PpdReferenceToCacheKey(reference),
                      base::Bind(&PpdProviderImpl::ResolvePpdCacheLookupDone,
                                 weak_factory_.GetWeakPtr(), reference, cb));
   }
 
   // Our only sources of long running ops are cache fetches and network fetches.
@@ skipping 94 matching lines @@
   // Fetch the file pointed at by url and store it in |file_fetch_contents_|.
   // Use |file_fetch_success_| to indicate success or failure.
   void FetchFile(const GURL& url) {
     CHECK(url.is_valid());
     CHECK(url.SchemeIs("file"));
     base::ThreadRestrictions::AssertIOAllowed();
     file_fetch_success_ = base::ReadFileToString(base::FilePath(url.path()),
                                                  &file_fetch_contents_);
   }
 
+  void FinishPpdResolution(const ResolvePpdCallback& cb,
+                           PpdProvider::CallbackResultCode result_code,
+                           const std::string& ppd_contents) {
+    if (result_code == PpdProvider::SUCCESS) {
+      base::SequencedTaskRunnerHandle::Get()->PostTask(
+          FROM_HERE, base::Bind(cb, PpdProvider::SUCCESS, ppd_contents,
+                                ExtractFiltersFromPpd(ppd_contents)));
+    } else {
+      // Just post the failure.
+      base::SequencedTaskRunnerHandle::Get()->PostTask(
+          FROM_HERE, base::Bind(cb, result_code, std::string(),
+                                std::vector<std::string>()));
+    }
+  }
+
   // Callback when the cache lookup for a ppd request finishes.  If we hit in
   // the cache, satisfy the resolution, otherwise kick it over to the fetcher
   // queue to be grabbed from a server.
   void ResolvePpdCacheLookupDone(const Printer::PpdReference& reference,
                                  const ResolvePpdCallback& cb,
                                  const PpdCache::FindResult& result) {
     if (result.success) {
       // Cache hit.
-      base::SequencedTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(cb, PpdProvider::SUCCESS, result.contents));
+      FinishPpdResolution(cb, PpdProvider::SUCCESS, result.contents);
     } else {
       // Cache miss.  Queue it to be satisfied by the fetcher queue.
       ppd_resolution_queue_.push_back({reference, cb});
       MaybeStartFetch();
     }
   }
 
   // Handler for the completion of the locales fetch.  This response should be a
   // list of strings, each of which is a locale in which we can answer queries
   // on the server.  The server (should) guarantee that we get 'en' as an
@@ skipping 140 matching lines @@
       }
     }
   }
 
   // This is called when |fetcher_| should have just downloaded a ppd.  If we
   // downloaded something successfully, use it to satisfy the front of the ppd
   // resolution queue, otherwise fail out that resolution.
   void OnPpdFetchComplete() {
     DCHECK(!ppd_resolution_queue_.empty());
     std::string contents;
+
     if ((ValidateAndGetResponseAsString(&contents) != PpdProvider::SUCCESS) ||
         contents.size() > kMaxPpdSizeBytes) {
-      base::SequencedTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(ppd_resolution_queue_.front().second,
-                                PpdProvider::SERVER_ERROR, std::string()));
+      FinishPpdResolution(ppd_resolution_queue_.front().second,
+                          PpdProvider::SERVER_ERROR, std::string());
     } else {
       ppd_cache_->Store(
           PpdReferenceToCacheKey(ppd_resolution_queue_.front().first), contents,
-
           base::Callback<void()>());
-      base::SequencedTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(ppd_resolution_queue_.front().second,
-                                PpdProvider::SUCCESS, contents));
+      FinishPpdResolution(ppd_resolution_queue_.front().second,
+                          PpdProvider::SUCCESS, contents);
     }
     ppd_resolution_queue_.pop_front();
   }
 
   // Called when |fetcher_| should have just downloaded a usb device map
   // for the vendor at the head of the |usb_resolution_queue_|.
   void OnUsbFetchComplete() {
     DCHECK(!usb_resolution_queue_.empty());
     std::string contents;
     std::string buffer;
@@ skipping 61 matching lines @@
   // the necessary index data from the server.  Note we leave any user-based ppd
   // resolutions intact, as they don't depend on the data we're missing.
   void FailQueuedServerPpdResolutions(PpdProvider::CallbackResultCode code) {
     std::deque<std::pair<Printer::PpdReference, ResolvePpdCallback>>
         filtered_queue;
 
     for (const auto& entry : ppd_resolution_queue_) {
       if (!entry.first.user_supplied_ppd_url.empty()) {
         filtered_queue.push_back(entry);
       } else {
-        base::SequencedTaskRunnerHandle::Get()->PostTask(
-            FROM_HERE, base::Bind(entry.second, code, std::string()));
+        FinishPpdResolution(entry.second, code, std::string());
       }
     }
     ppd_resolution_queue_ = std::move(filtered_queue);
   }
 
   // Given a list of possible locale strings (e.g. 'en-GB'), determine which of
   // them we should use to best serve results for the browser locale (which was
   // given to us at construction time).
   std::string GetBestLocale(const std::vector<std::string>& available_locales) {
     // First look for an exact match.  If we find one, just use that.
@@ skipping 240 matching lines @@
     scoped_refptr<net::URLRequestContextGetter> url_context_getter,
     scoped_refptr<PpdCache> ppd_cache,
     scoped_refptr<base::SequencedTaskRunner> disk_task_runner,
     const PpdProvider::Options& options) {
   return scoped_refptr<PpdProvider>(
       new PpdProviderImpl(browser_locale, url_context_getter, ppd_cache,
                           disk_task_runner, options));
 }
 }  // namespace printing
 }  // namespace chromeos