Implement IPP Get-Jobs and Get-Printer-Attributes requests.

printing/backend/cups_jobs.cc

Index: printing/backend/cups_jobs.cc
diff --git a/printing/backend/cups_jobs.cc b/printing/backend/cups_jobs.cc
new file mode 100644
index 0000000000000000000000000000000000000000..97288fcc5f2cdf7c18e421e67b95569019b65030
--- /dev/null
+++ b/printing/backend/cups_jobs.cc
@@ -0,0 +1,406 @@
+// Copyright 2017 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_jobs.h"
+
+#include <cups/ipp.h>
+
+#include <map>
+
+#include "base/logging.h"
+#include "base/strings/string_piece.h"
+#include "base/strings/stringprintf.h"
+
+namespace printing {
+namespace {
+
+// printer attributes
+const char kPrinterUri[] = "printer-uri";
+const char kPrinterState[] = "printer-state";
+const char kPrinterStateReasons[] = "printer-state-reasons";
+const char kPrinterStateMessage[] = "printer-state-message";
+
+// job attributes
+const char kJobUri[] = "job-uri";
+const char kJobId[] = "job-id";
+const char kJobState[] = "job-state";
+const char kJobStateReasons[] = "job-state-reasons";
+const char kJobStateMessage[] = "job-state-message";
+const char kJobImpressionsCompleted[] = "job-impressions-completed";
+const char kTimeAtProcessing[] = "time-at-processing";
+
+// request parameters
+const char kRequestedAttributes[] = "requested-attributes";
+const char kWhichJobs[] = "which-jobs";
+const char kLimit[] = "limit";
+
+// request values
+const char kCompleted[] = "completed";
+const char kNotCompleted[] = "not-completed";
+
+// printer state severities
+const char kSeverityReport[] = "report";
+const char kSeverityWarn[] = "warning";
+const char kSeverityError[] = "error";
+
+// printer state reason values
+const char kNone[] = "none";
+const char kMediaNeeded[] = "media-needed";
+const char kMediaJam[] = "media-jam";
+const char kMovingToPaused[] = "moving-to-paused";
+const char kPaused[] = "paused";
+const char kShutdown[] = "shutdown";
+const char kConnectingToDevice[] = "connecting-to-device";
+const char kTimedOut[] = "timed-out";
+const char kStopping[] = "stopping";
+const char kStoppedPartly[] = "stopped-partly";
+const char kTonerLow[] = "toner-low";
+const char kTonerEmpty[] = "toner-empty";
+const char kSpoolAreaFull[] = "spool-area-full";
+const char kCoverOpen[] = "cover-open";
+const char kInterlockOpen[] = "interlock-open";
+const char kDoorOpen[] = "door-open";
+const char kInputTrayMissing[] = "input-tray-missing";
+const char kMediaLow[] = "media-low";
+const char kMediaEmpty[] = "media-empty";
+const char kOutputTrayMissing[] = "output-tray-missing";
+const char kOutputAreaAlmostFull[] = "output-area-almost-full";
+const char kOutputAreaFull[] = "output-area-full";
+const char kMarkerSupplyLow[] = "marker-supply-low";
+const char kMarkerSupplyEmpty[] = "marker-supply-empty";
+const char kMarkerWasteAlmostFull[] = "marker-waste-almost-full";
+const char kMarkerWasteFull[] = "marker-waste-full";
+const char kFuserOverTemp[] = "fuser-over-temp";
+const char kFuserUnderTemp[] = "fuser-under-temp";
+const char kOpcNearEol[] = "opc-near-eol";
+const char kOpcLifeOver[] = "opc-life-over";
+const char kDeveloperLow[] = "developer-low";
+const char kDeveloperEmpty[] = "developer-empty";
+const char kInterpreterResourceUnavailable[] =
+    "interpreter-resource-unavailable";
+
+struct IppDeleter {

[Carlson, 2017/02/24 00:02:08]

I don't think you need to define a struct for this, you should be able to pass
&ippDelete directly to the unique_ptr constructor, but if you like it better,
sure.

[skau, 2017/02/28 00:59:59]

I think the Deleter must be a type.  How do you do that?

[Carlson, 2017/02/28 01:29:47]

You can use a function pointer as the second type, e.g.:

#include <memory>

#include <stdio.h>

struct Foo {
  Foo() { printf("Constructed\n"); }
};

void deleteit(Foo* t) {
  printf("Baleeted\n");
}

int main() {
  std::unique_ptr<Foo, void(*)(Foo*)> p(new Foo, &deleteit);
  return 0;
}

[skau, 2017/02/28 19:01:16]

Right.  Function pointers.  This would be awful without auto.  Or type aliasing.

+  void operator()(ipp_t* ipp) const { ippDelete(ipp); }
+};
+
+std::unique_ptr<ipp_t, IppDeleter> WrapIpp(ipp_t* ipp) {
+  return std::unique_ptr<ipp_t, IppDeleter>(ipp, IppDeleter());
+}
+
+CupsJob::JobState ToJobState(ipp_attribute_t* attr) {
+  DCHECK_EQ(IPP_TAG_ENUM, ippGetValueTag(attr));
+  int state = ippGetInteger(attr, 0);
+  CupsJob::JobState converted_state = CupsJob::UNKNOWN;
+  switch (state) {
+    case IPP_JOB_ABORTED:
+      converted_state = CupsJob::ABORTED;
+      break;
+    case IPP_JOB_CANCELLED:
+      converted_state = CupsJob::CANCELED;
+      break;
+    case IPP_JOB_COMPLETED:
+      converted_state = CupsJob::COMPLETED;
+      break;
+    case IPP_JOB_HELD:
+      converted_state = CupsJob::HELD;
+      break;
+    case IPP_JOB_PENDING:
+      converted_state = CupsJob::PENDING;
+      break;
+    case IPP_JOB_PROCESSING:
+      converted_state = CupsJob::PROCESSING;
+      break;
+    case IPP_JOB_STOPPED:
+      converted_state = CupsJob::STOPPED;
+      break;
+    default:
+      NOTREACHED() << "Unidentifed state " << state;
+      break;
+  }
+
+  return converted_state;
+}
+
+using PR = PrinterStatus::PrinterReason::Reason;
+using PSeverity = PrinterStatus::PrinterReason::Severity;
+
+const std::map<base::StringPiece, PR>& GetLabelToReason() {
+  static const std::map<base::StringPiece, PR>* kLabelToReason =

[Carlson, 2017/02/24 00:02:08]

I'm pretty sure this doesn't need to be a pointer.

[skau, 2017/02/28 00:59:59]

I think it needs to be a pointer to avoid being allocated at load.  Or, I'm
reading this wrong:
http://en.cppreference.com/w/cpp/language/storage_duration#Storage_duration

[Carlson, 2017/02/28 01:29:47]

I think you have an incomplete reading here.  The (static) *storage* for the
object is, indeed allocated at load time (presumably in .bss?  I dont' actually
know that, but it's not important here), but the *initialization* for the object
is deferred until first entry into the function.  And is thread safe.  This is
the guarantee that makes Meyer's Singleton pattern work.

See "Static Local Variables" here:

http://en.cppreference.com/w/cpp/language/storage_duration

[skau, 2017/02/28 19:01:16]

Yep.  I read the wrong heading.  Also, I had to Google "Meyer's Singleton".

+      new std::map<base::StringPiece, PR>{
+          {kNone, PR::NONE},
+          {kMediaNeeded, PR::MEDIA_NEEDED},
+          {kMediaJam, PR::MEDIA_JAM},
+          {kMovingToPaused, PR::MOVING_TO_PAUSED},
+          {kPaused, PR::PAUSED},
+          {kShutdown, PR::SHUTDOWN},
+          {kConnectingToDevice, PR::CONNECTING_TO_DEVICE},
+          {kTimedOut, PR::TIMED_OUT},
+          {kStopping, PR::STOPPING},
+          {kStoppedPartly, PR::STOPPED_PARTLY},
+          {kTonerLow, PR::TONER_LOW},
+          {kTonerEmpty, PR::TONER_EMPTY},
+          {kSpoolAreaFull, PR::SPOOL_AREA_FULL},
+          {kCoverOpen, PR::COVER_OPEN},
+          {kInterlockOpen, PR::INTERLOCK_OPEN},
+          {kDoorOpen, PR::DOOR_OPEN},
+          {kInputTrayMissing, PR::INPUT_TRAY_MISSING},
+          {kMediaLow, PR::MEDIA_LOW},
+          {kMediaEmpty, PR::MEDIA_EMPTY},
+          {kOutputTrayMissing, PR::OUTPUT_TRAY_MISSING},
+          {kOutputAreaAlmostFull, PR::OUTPUT_AREA_ALMOST_FULL},
+          {kOutputAreaFull, PR::OUTPUT_AREA_FULL},
+          {kMarkerSupplyLow, PR::MARKER_SUPPLY_LOW},
+          {kMarkerSupplyEmpty, PR::MARKER_SUPPLY_EMPTY},
+          {kMarkerWasteAlmostFull, PR::MARKER_WASTE_ALMOST_FULL},
+          {kMarkerWasteFull, PR::MARKER_WASTE_FULL},
+          {kFuserOverTemp, PR::FUSER_OVER_TEMP},
+          {kFuserUnderTemp, PR::FUSER_UNDER_TEMP},
+          {kOpcNearEol, PR::OPC_NEAR_EOL},
+          {kOpcLifeOver, PR::OPC_LIFE_OVER},
+          {kDeveloperLow, PR::DEVELOPER_LOW},
+          {kDeveloperEmpty, PR::DEVELOPER_EMPTY},
+          {kInterpreterResourceUnavailable,
+           PR::INTERPRETER_RESOURCE_UNAVAILABLE},
+      };
+  return *kLabelToReason;
+}
+
+PrinterStatus::PrinterReason::Reason ToReason(base::StringPiece reason) {

[Carlson, 2017/02/24 00:02:09]

Please add function comments for functions not declared in the header

[skau, 2017/02/28 00:59:59]

Done.

+  const auto& enum_map = GetLabelToReason();
+  const auto& entry = enum_map.find(reason);
+  if (entry == enum_map.end()) {
+    return PR::UNKNOWN_REASON;
+  }
+
+  return entry->second;
+}
+
+PSeverity ToSeverity(base::StringPiece severity) {
+  if (severity == kSeverityError)
+    return PSeverity::ERROR;
+
+  if (severity == kSeverityWarn)
+    return PSeverity::WARNING;
+
+  if (severity == kSeverityReport)
+    return PSeverity::REPORT;
+
+  return PSeverity::UNKNOWN_SEVERITY;
+}
+
+PrinterStatus::PrinterReason ToPrinterReason(base::StringPiece reason) {
+  PrinterStatus::PrinterReason parsed;
+
+  if (reason == kNone) {
+    parsed.reason = PrinterStatus::PrinterReason::NONE;
+    parsed.severity = PrinterStatus::PrinterReason::UNKNOWN_SEVERITY;
+    return parsed;
+  }
+
+  size_t last_dash = reason.rfind('-');
+  auto severity = PSeverity::UNKNOWN_SEVERITY;
+  if (last_dash != base::StringPiece::npos) {
+    // try to parse the last part of the string as the severity.
+    severity = ToSeverity(reason.substr(last_dash + 1));
+  }
+
+  if (severity == PSeverity::UNKNOWN_SEVERITY) {
+    // Severity is unknown.  No severity in the reason.
+    // Per spec, if there is no severity, severity is error.
+    parsed.severity = PrinterStatus::PrinterReason::ERROR;
+    parsed.reason = ToReason(reason);
+  } else {
+    parsed.severity = severity;
+    // reason is the beginning of the string
+    parsed.reason = ToReason(reason.substr(0, last_dash));
+  }
+
+  return parsed;
+}
+
+void ParseCollection(ipp_attribute_t* attr,
+                     std::vector<std::string>* collection) {
+  int count = ippGetCount(attr);
+  for (int i = 0; i < count; i++) {
+    base::StringPiece value = ippGetString(attr, i, nullptr);
+    collection->push_back(value.as_string());
+  }
+}
+
+void ParseField(ipp_attribute_t* attr, base::StringPiece name, CupsJob* job) {
+  DCHECK(!name.empty());
+  if (name == kJobId) {
+    job->id = ippGetInteger(attr, 0);
+  } else if (name == kJobImpressionsCompleted) {
+    job->current_pages = ippGetInteger(attr, 0);
+  } else if (name == kJobState) {
+    job->state = ToJobState(attr);
+  } else if (name == kJobStateReasons) {
+    ParseCollection(attr, &(job->state_reasons));
+  } else if (name == kJobStateMessage) {
+    job->state_message = ippGetString(attr, 0, nullptr);
+  } else if (name == kTimeAtProcessing) {
+    job->processing_started = ippGetInteger(attr, 0);
+  }
+}
+
+// forward decl

[Carlson, 2017/02/24 00:02:08]

Comment not useful, more useful would be why forward declaration is needed here.

[skau, 2017/02/28 00:59:58]

Done.

+void ParseFields(ipp_t* response,
+                 const std::string& printer_id,
+                 ipp_attribute_t* attr,
+                 CupsJob* current_job,
+                 std::vector<CupsJob>* jobs);
+
+void NewJob(ipp_t* response,
+            const std::string& printer_id,
+            std::vector<CupsJob>* jobs) {
+  jobs->emplace_back();
+  CupsJob* job = &(*jobs)[jobs->size() - 1];

[Carlson, 2017/02/24 00:02:09]

&(*jobs)[jobs->size() - 1]

is the same as

&jobs->back()

I think.

[skau, 2017/02/28 00:59:59]

Done.

In C++17, emplace_back will return a reference. :)  Not that we'll be able to
use that any time soon ...

+  job->printer_id = printer_id;
+  ParseFields(response, printer_id, ippNextAttribute(response), job, jobs);
+}
+
+void ParseFields(ipp_t* response,
+                 const std::string& printer_id,
+                 ipp_attribute_t* attr,
+                 CupsJob* current_job,
+                 std::vector<CupsJob>* jobs) {
+  if (!attr)
+    return;
+
+  base::StringPiece attribute_name = ippGetName(attr);
+  // Separators indicate a new job.  Separators have empty names.
+  if (attribute_name.empty()) {
+    NewJob(response, printer_id, jobs);
+    return;
+  }
+
+  // Continue to populate the job fileds.
+  ParseField(attr, attribute_name, current_job);
+
+  ParseFields(response, printer_id, ippNextAttribute(response), current_job,
+              jobs);
+}
+
+// Returns the uri for printer with |id| as served by CUPS.
+std::string PrinterUriFromName(const std::string& id) {
+  return base::StringPrintf("ipp://localhost/printers/%s", id.c_str());

[Carlson, 2017/02/24 00:02:08]

Doesn't this need escaping, depending on the id?  Or do we have sufficient
restrictions on the contents of id that we know it won't need escaping?

[skau, 2017/02/28 00:59:59]

I don't think so. CUPS rejects non-ascii characters and spaces in names so there
won't be an id for which this won't resolve the printer correctly.  It can,
however, generate a funky url.  Error checking should be handled higher up the
stack.

[Carlson, 2017/02/28 01:29:47]

OK, but I already found a bug in CUPS' validation of that.  :)

[skau, 2017/02/28 19:01:16]

Our ids will be valid at least since they're a SHA1s hex-encoded or a UUID.

+}
+
+}  // namespace
+
+void ParseJobsResponse(ipp_t* response,
+                       const std::string& printer_id,
+                       std::vector<CupsJob>* jobs) {
+  // Advance the position in the response to the jobs section.
+  ipp_attribute_t* attr = ippFirstAttribute(response);
+  while (attr != nullptr && ippGetGroupTag(attr) != IPP_TAG_JOB) {
+    attr = ippNextAttribute(response);
+  }
+
+  if (attr != nullptr) {
+    NewJob(response, printer_id, jobs);
+  }
+}
+
+void ParsePrinterStatus(ipp_t* response, PrinterStatus* printer_status) {
+  for (ipp_attribute_t* attr = ippFirstAttribute(response); attr != nullptr;
+       attr = ippNextAttribute(response)) {
+    base::StringPiece name = ippGetName(attr);
+    if (name.empty()) {
+      continue;
+    }
+
+    if (name == kPrinterState) {
+      DCHECK_EQ(IPP_TAG_ENUM, ippGetValueTag(attr));
+      printer_status->state = static_cast<ipp_pstate_t>(ippGetInteger(attr, 0));
+    } else if (name == kPrinterStateReasons) {
+      std::vector<std::string> reason_strings;
+      ParseCollection(attr, &reason_strings);
+      for (const std::string& reason : reason_strings) {

[Carlson, 2017/02/24 00:02:09]

It's legit to do

for (const std::string& reason : ParseCollection(attr, &reason_strings)) {
}
if you want, but if you think that's gross, fair enough.

[skau, 2017/02/28 00:59:59]

I don't think so, ParseCollection returns void.  Does C++11 guarantee that
expression right of the : is only evaluated once?

[Carlson, 2017/02/28 01:29:47]

Oops, you're right, didn't look closely at the function.  But yes to the latter
part.  

+        printer_status->reasons.push_back(ToPrinterReason(reason));
+      }
+    } else if (name == kPrinterStateMessage) {
+      printer_status->message = ippGetString(attr, 0, nullptr);
+    }
+  }
+}
+
+bool GetPrinterStatus(http_t* http,
+                      const std::string& printer_id,
+                      PrinterStatus* printer_status) {
+  DCHECK(http);
+
+  auto request = WrapIpp(ippNewRequest(IPP_OP_GET_PRINTER_ATTRIBUTES));
+
+  const std::string printer_uri = PrinterUriFromName(printer_id);
+  ippAddString(request.get(), IPP_TAG_OPERATION, IPP_TAG_URI, kPrinterUri,
+               nullptr, printer_uri.data());
+
+  std::vector<const char*> printer_attributes = {
+      kPrinterState, kPrinterStateReasons, kPrinterStateMessage};
+
+  ippAddStrings(request.get(), IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
+                kRequestedAttributes, printer_attributes.size(), nullptr,
+                printer_attributes.data());
+
+  auto response =
+      WrapIpp(cupsDoRequest(http, request.release(), printer_uri.c_str()));
+
+  if (ippGetStatusCode(response.get()) != IPP_STATUS_OK)
+    return false;
+
+  ParsePrinterStatus(response.get(), printer_status);
+
+  return true;
+}
+
+bool GetCupsJobs(http_t* http,
+                 const std::string& printer_id,
+                 int limit,
+                 bool completed,
+                 std::vector<CupsJob>* jobs) {
+  DCHECK(http);
+
+  auto request = WrapIpp(ippNewRequest(IPP_OP_GET_JOBS));
+  const std::string printer_uri = PrinterUriFromName(printer_id);
+  ippAddString(request.get(), IPP_TAG_OPERATION, IPP_TAG_URI, kPrinterUri,
+               nullptr, printer_uri.data());
+  ippAddInteger(request.get(), IPP_TAG_OPERATION, IPP_TAG_INTEGER, kLimit,
+                limit);
+
+  std::vector<const char*> job_attributes = {
+      kJobUri,          kJobId,           kJobState,
+      kJobStateReasons, kJobStateMessage, kJobImpressionsCompleted,
+      kTimeAtProcessing};
+
+  ippAddStrings(request.get(), IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
+                kRequestedAttributes, job_attributes.size(), nullptr,
+                job_attributes.data());
+
+  ippAddString(request.get(), IPP_TAG_OPERATION, IPP_TAG_KEYWORD, kWhichJobs,
+               nullptr, completed ? kCompleted : kNotCompleted);
+
+  if (ippValidateAttributes(request.get()) != 1) {
+    LOG(WARNING) << "Could not validate ipp request: " << cupsLastErrorString();
+    return false;
+  }
+
+  // cupsDoRequest will delete the request.
+  auto response =
+      WrapIpp(cupsDoRequest(http, request.release(), printer_uri.c_str()));
+
+  ipp_status_t status = ippGetStatusCode(response.get());
+
+  if (status != IPP_OK) {
+    LOG(WARNING) << "IPP Error: " << cupsLastErrorString();
+    return false;
+  }
+
+  ParseJobsResponse(response.get(), printer_id, jobs);
+
+  return true;
+}
+
+}  // namespace printing