xml_util.cc

// Copyright 2020 The Chromium OS 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 "xml_util.h"

#include <memory>
#include <utility>
#include <string>

#include <base/containers/flat_map.h>
#include <libxml/tree.h>

namespace {

struct XmlNodeDeleter {
  void operator()(xmlNode* p) { xmlFreeNode(p); }
};
using UniqueXmlNodePtr = std::unique_ptr<xmlNode, XmlNodeDeleter>;

struct XmlDocDeleter {
  void operator()(xmlDoc* p) { xmlFreeDoc(p); }
};
using UniqueXmlDocPtr = std::unique_ptr<xmlDoc, XmlDocDeleter>;

constexpr char kPwgNs[] = "pwg";
constexpr char kScanNs[] = "scan";
using namespace_map = base::flat_map<std::string, xmlNs*>;

inline const xmlChar* XmlCast(const char* p) {
  return reinterpret_cast<const xmlChar*>(p);
}

// Serialize the xml tree in |root| into a vector. Consumes |root| and frees
// its memory.
std::vector<uint8_t> Serialize(UniqueXmlNodePtr root) {
  UniqueXmlDocPtr doc(xmlNewDoc(XmlCast("1.0")));
  // |doc| takes ownership of |root| here.
  xmlDocSetRootElement(doc.get(), root.release());

  xmlChar* buf;
  int length;
  xmlDocDumpFormatMemoryEnc(doc.get(), &buf, &length, "UTF-8", true);
  std::vector<uint8_t> xml(buf, buf + length);
  xmlFree(buf);

  return xml;
}

// Adds a new node with namespace |ns| called |name| as a child of |node|.
// Returns a non-owning pointer to the new node.
xmlNode* AddNode(xmlNode* node, xmlNs* ns, const std::string& name) {
  xmlNode* child = xmlNewNode(ns, XmlCast(name.c_str()));
  xmlAddChild(node, child);
  return child;
}

// Adds a new node with namespace |ns| called |name| and containing |content|
// as a child of |node|.
void AddNodeWithContent(xmlNode* node,
                        xmlNs* ns,
                        const std::string& name,
                        const std::string& content) {
  xmlNode* child = xmlNewNode(ns, XmlCast(name.c_str()));
  xmlNodeSetContent(child, XmlCast(content.c_str()));
  xmlAddChild(node, child);
}

UniqueXmlNodePtr SourceCapabilitiesAsXml(const SourceCapabilities& caps,
                                         const std::string& name,
                                         namespace_map* namespaces) {
  xmlNs* pwg = (*namespaces)[kPwgNs];
  xmlNs* scan = (*namespaces)[kScanNs];
  UniqueXmlNodePtr root(xmlNewNode(scan, XmlCast(name.c_str())));

  AddNodeWithContent(root.get(), scan, "MinWidth", "16");
  AddNodeWithContent(root.get(), scan, "MaxWidth", "2550");
  AddNodeWithContent(root.get(), scan, "MinHeight", "16");
  AddNodeWithContent(root.get(), scan, "MaxHeight", "3507");
  AddNodeWithContent(root.get(), scan, "MaxScanRegions", "1");

  xmlNode* profiles = AddNode(root.get(), scan, "SettingProfiles");
  xmlNode* profile = AddNode(profiles, scan, "SettingProfile");
  xmlNode* color_modes = AddNode(profile, scan, "ColorModes");
  for (const std::string& mode : caps.color_modes) {
    AddNodeWithContent(color_modes, scan, "ColorMode", mode);
  }
  xmlNode* document_formats = AddNode(profile, scan, "DocumentFormats");
  for (const std::string& format : caps.formats) {
    AddNodeWithContent(document_formats, pwg, "DocumentFormat", format);
  }

  xmlNode* resolutions = AddNode(profile, scan, "SupportedResolutions");
  xmlNode* discrete_resolutions =
      AddNode(resolutions, scan, "DiscreteResolutions");
  for (int resolution : caps.resolutions) {
    xmlNode* r = AddNode(discrete_resolutions, scan, "DiscreteResolution");
    AddNodeWithContent(r, scan, "XResolution", std::to_string(resolution));
    AddNodeWithContent(r, scan, "YResolution", std::to_string(resolution));
  }

  xmlNode* intents = AddNode(root.get(), scan, "SupportedIntents");
  AddNodeWithContent(intents, scan, "Intent", "Document");
  AddNodeWithContent(intents, scan, "Intent", "TextAndGraphic");
  AddNodeWithContent(intents, scan, "Intent", "Photo");
  AddNodeWithContent(intents, scan, "Intent", "Preview");

  AddNodeWithContent(root.get(), scan, "MaxOpticalXResolution", "2400");
  AddNodeWithContent(root.get(), scan, "MaxOpticalYResolution", "2400");
  AddNodeWithContent(root.get(), scan, "RiskyLeftMargin", "0");
  AddNodeWithContent(root.get(), scan, "RiskyRightMargin", "0");
  AddNodeWithContent(root.get(), scan, "RiskyTopMargin", "0");
  AddNodeWithContent(root.get(), scan, "RiskyBottomMargin", "0");

  return root;
}

// Serialize a map of UUIDs to JobInfo into the XML format expected for
// eSCL ScannerStatus.
// Returns a node which can be merged into the larger XML document.
UniqueXmlNodePtr JobListAsXml(const base::flat_map<std::string, JobInfo>& jobs,
                              namespace_map* namespaces) {
  xmlNs* pwg = (*namespaces)[kPwgNs];
  xmlNs* scan = (*namespaces)[kScanNs];

  UniqueXmlNodePtr root(xmlNewNode(scan, XmlCast("Jobs")));
  for (const auto& job : jobs) {
    const std::string& uuid = job.first;
    const JobInfo& info = job.second;
    xmlNode* job_info = AddNode(root.get(), scan, "JobInfo");
    AddNodeWithContent(job_info, pwg, "JobUri", "/eSCL/ScanJobs/" + uuid);
    AddNodeWithContent(job_info, pwg, "JobUuid", "urn:uuid:" + uuid);

    // Different scanners are not consistent with how they report scan job age.
    // Arbitrarily report age as elapsed seconds.
    base::TimeDelta elapsed = base::TimeTicks::Now() - info.created;
    AddNodeWithContent(job_info, scan, "Age",
                       std::to_string(elapsed.InSeconds()));

    int images_completed = 0;
    int images_to_transfer = 0;
    std::string job_state;
    // These reason strings are defined in the PWG standard. There are other
    // values possible, but for now, just use a typical value.
    std::string reason;
    switch (info.state) {
      case kPending:
        images_completed = 1;
        images_to_transfer = 1;
        job_state = "Pending";
        reason = "JobScanning";
        break;
      case kCanceled:
        images_completed = 0;
        images_to_transfer = 0;
        job_state = "Canceled";
        reason = "JobTimedOut";
        break;
      case kCompleted:
        images_completed = 1;
        images_to_transfer = 0;
        job_state = "Completed";
        reason = "JobCompletedSuccessfully";
        break;
    }

    AddNodeWithContent(job_info, pwg, "ImagesCompleted",
                       std::to_string(images_completed));
    AddNodeWithContent(job_info, pwg, "ImagesToTransfer",
                       std::to_string(images_to_transfer));
    AddNodeWithContent(job_info, pwg, "JobState", job_state);
    xmlNode* job_state_reasons = AddNode(job_info, pwg, "JobStateReasons");
    AddNodeWithContent(job_state_reasons, pwg, "JobStateReason", reason);
  }

  return root;
}

}  // namespace

std::vector<uint8_t> ScannerCapabilitiesAsXml(const ScannerCapabilities& caps) {
  UniqueXmlNodePtr root(xmlNewNode(nullptr, XmlCast("ScannerCapabilities")));

  xmlNs* pwg =
      xmlNewNs(root.get(), XmlCast("http://www.pwg.org/schemas/2010/12/sm"),
               XmlCast("pwg"));
  xmlNs* scan = xmlNewNs(
      root.get(), XmlCast("http://schemas.hp.com/imaging/escl/2011/05/03"),
      XmlCast("scan"));
  xmlNewNs(root.get(), XmlCast("http://www.w3.org/2001/XMLSchema-instance"),
           XmlCast("xsi"));
  xmlSetNs(root.get(), scan);

  namespace_map namespaces;
  namespaces[kPwgNs] = pwg;
  namespaces[kScanNs] = scan;

  AddNodeWithContent(root.get(), pwg, "Version", "2.63");
  AddNodeWithContent(root.get(), pwg, "MakeAndModel", caps.make_and_model);
  AddNodeWithContent(root.get(), pwg, "SerialNumber", caps.serial_number);

  xmlNode* platen = AddNode(root.get(), scan, "Platen");
  UniqueXmlNodePtr platen_caps = SourceCapabilitiesAsXml(
      caps.platen_capabilities, "PlatenInputCaps", &namespaces);
  xmlAddChild(platen, platen_caps.release());

  return Serialize(std::move(root));
}

std::vector<uint8_t> ScannerStatusAsXml(const ScannerStatus& status) {
  UniqueXmlNodePtr root(xmlNewNode(nullptr, XmlCast("ScannerStatus")));

  xmlNs* scan = xmlNewNs(
      root.get(), XmlCast("http://schemas.hp.com/imaging/escl/2011/05/03"),
      XmlCast("scan"));
  xmlNs* pwg =
      xmlNewNs(root.get(), XmlCast("http://www.pwg.org/schemas/2010/12/sm"),
               XmlCast("pwg"));
  xmlNewNs(root.get(), XmlCast("http://www.w3.org/2001/XMLSchema-instance"),
           XmlCast("xsi"));
  xmlSetNs(root.get(), scan);

  AddNodeWithContent(root.get(), pwg, "Version", "2.6.3");
  AddNodeWithContent(root.get(), pwg, "State", status.idle ? "Idle" : "Busy");

  // Add a list of all of the scan jobs
  namespace_map namespaces;
  namespaces[kPwgNs] = pwg;
  namespaces[kScanNs] = scan;
  UniqueXmlNodePtr jobs = JobListAsXml(status.jobs, &namespaces);
  xmlAddChild(root.get(), jobs.release());

  return Serialize(std::move(root));
}