Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 476 insertions, 0 deletions

diff --git a/widget/nsPrinterCUPS.cpp b/widget/nsPrinterCUPS.cpp
new file mode 100644
index 0000000000..a8656de23f
--- /dev/null
+++ b/widget/nsPrinterCUPS.cpp
@@ -0,0 +1,476 @@
+/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 2; -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsPrinterCUPS.h"
+
+#include "mozilla/gfx/2D.h"
+#include "mozilla/GkRustUtils.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/StaticPrefs_print.h"
+#include "nsTHashtable.h"
+#include "nsPaper.h"
+#include "nsPrinterBase.h"
+#include "nsPrintSettingsImpl.h"
+
+using namespace mozilla;
+using MarginDouble = mozilla::gfx::MarginDouble;
+
+// Requested attributes for IPP requests, just the CUPS version now.
+static constexpr Array<const char* const, 1> requestedAttributes{
+    "cups-version"};
+
+static constexpr double kPointsPerHundredthMillimeter = 72.0 / 2540.0;
+
+static PaperInfo MakePaperInfo(const nsAString& aName,
+                               const cups_size_t& aMedia) {
+  // XXX Do we actually have the guarantee that this is utf-8?
+  NS_ConvertUTF8toUTF16 paperId(aMedia.media);  // internal paper name/ID
+  return PaperInfo(
+      paperId, aName,
+      {aMedia.width * kPointsPerHundredthMillimeter,
+       aMedia.length * kPointsPerHundredthMillimeter},
+      Some(gfx::MarginDouble{aMedia.top * kPointsPerHundredthMillimeter,
+                             aMedia.right * kPointsPerHundredthMillimeter,
+                             aMedia.bottom * kPointsPerHundredthMillimeter,
+                             aMedia.left * kPointsPerHundredthMillimeter}));
+}
+
+// Fetches the CUPS version for the print server controlling the printer. This
+// will only modify the output arguments if the fetch succeeds.
+static void FetchCUPSVersionForPrinter(const nsCUPSShim& aShim,
+                                       const cups_dest_t* const aDest,
+                                       uint64_t& aOutMajor, uint64_t& aOutMinor,
+                                       uint64_t& aOutPatch) {
+  // Make an IPP request to the server for the printer.
+  const char* const uri = aShim.cupsGetOption(
+      "printer-uri-supported", aDest->num_options, aDest->options);
+  if (!uri) {
+    return;
+  }
+
+  ipp_t* const ippRequest = aShim.ippNewRequest(IPP_OP_GET_PRINTER_ATTRIBUTES);
+
+  // Set the URI we want to use.
+  aShim.ippAddString(ippRequest, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
+                     nullptr, uri);
+
+  // Set the attributes to request.
+  aShim.ippAddStrings(ippRequest, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
+                      "requested-attributes", requestedAttributes.Length,
+                      nullptr, &(requestedAttributes[0]));
+
+  // Use the default HTTP connection to query the CUPS server itself to get
+  // the CUPS version.
+  // Note that cupsDoRequest will delete the request whether it succeeds or
+  // fails, so we should not use ippDelete on it.
+  if (ipp_t* const ippResponse =
+          aShim.cupsDoRequest(CUPS_HTTP_DEFAULT, ippRequest, "/")) {
+    ipp_attribute_t* const versionAttrib =
+        aShim.ippFindAttribute(ippResponse, "cups-version", IPP_TAG_TEXT);
+    if (versionAttrib && aShim.ippGetCount(versionAttrib) == 1) {
+      const char* versionString = aShim.ippGetString(versionAttrib, 0, nullptr);
+      MOZ_ASSERT(versionString);
+      // On error, GkRustUtils::ParseSemVer will not modify its arguments.
+      GkRustUtils::ParseSemVer(
+          nsDependentCSubstring{MakeStringSpan(versionString)}, aOutMajor,
+          aOutMinor, aOutPatch);
+    }
+    aShim.ippDelete(ippResponse);
+  }
+}
+
+nsPrinterCUPS::~nsPrinterCUPS() {
+  PrinterInfoLock lock = mPrinterInfoMutex.Lock();
+  if (lock->mPrinterInfo) {
+    mShim.cupsFreeDestInfo(lock->mPrinterInfo);
+  }
+  if (lock->mPrinter) {
+    mShim.cupsFreeDests(1, lock->mPrinter);
+  }
+}
+
+NS_IMETHODIMP
+nsPrinterCUPS::GetName(nsAString& aName) {
+  GetPrinterName(aName);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrinterCUPS::GetSystemName(nsAString& aName) {
+  PrinterInfoLock lock = mPrinterInfoMutex.Lock();
+  CopyUTF8toUTF16(MakeStringSpan(lock->mPrinter->name), aName);
+  return NS_OK;
+}
+
+void nsPrinterCUPS::GetPrinterName(nsAString& aName) const {
+  if (mDisplayName.IsEmpty()) {
+    aName.Truncate();
+    PrinterInfoLock lock = mPrinterInfoMutex.Lock();
+    CopyUTF8toUTF16(MakeStringSpan(lock->mPrinter->name), aName);
+  } else {
+    aName = mDisplayName;
+  }
+}
+
+const char* nsPrinterCUPS::LocalizeMediaName(http_t& aConnection,
+                                             cups_size_t& aMedia) const {
+  // The returned string is owned by mPrinterInfo.
+  // https://www.cups.org/doc/cupspm.html#cupsLocalizeDestMedia
+  if (!mShim.cupsLocalizeDestMedia) {
+    return aMedia.media;
+  }
+  PrinterInfoLock lock = TryEnsurePrinterInfo();
+  return mShim.cupsLocalizeDestMedia(&aConnection, lock->mPrinter,
+                                     lock->mPrinterInfo,
+                                     CUPS_MEDIA_FLAGS_DEFAULT, &aMedia);
+}
+
+bool nsPrinterCUPS::SupportsDuplex() const {
+  return Supports(CUPS_SIDES, CUPS_SIDES_TWO_SIDED_PORTRAIT);
+}
+
+bool nsPrinterCUPS::SupportsMonochrome() const {
+  if (!SupportsColor()) {
+    return true;
+  }
+  return StaticPrefs::print_cups_monochrome_enabled();
+}
+
+bool nsPrinterCUPS::SupportsColor() const {
+  // CUPS 2.1 (particularly as used in Ubuntu 16) is known to have inaccurate
+  // results for CUPS_PRINT_COLOR_MODE.
+  // See https://bugzilla.mozilla.org/show_bug.cgi?id=1660658#c15
+  if (!IsCUPSVersionAtLeast(2, 2, 0)) {
+    return true;  // See comment for PrintSettingsInitializer.mPrintInColor
+  }
+  return Supports(CUPS_PRINT_COLOR_MODE, CUPS_PRINT_COLOR_MODE_AUTO) ||
+         Supports(CUPS_PRINT_COLOR_MODE, CUPS_PRINT_COLOR_MODE_COLOR) ||
+         !Supports(CUPS_PRINT_COLOR_MODE, CUPS_PRINT_COLOR_MODE_MONOCHROME);
+}
+
+bool nsPrinterCUPS::SupportsCollation() const {
+  // We can't depend on cupsGetIntegerOption existing.
+  PrinterInfoLock lock = mPrinterInfoMutex.Lock();
+  const char* const value = FindCUPSOption(lock, "printer-type");
+  if (!value) {
+    return false;
+  }
+  // If the value is non-numeric, then atoi will return 0, which will still
+  // cause this function to return false.
+  const int type = atoi(value);
+  return type & CUPS_PRINTER_COLLATE;
+}
+
+nsPrinterBase::PrinterInfo nsPrinterCUPS::CreatePrinterInfo() const {
+  Connection connection{mShim};
+  return PrinterInfo{PaperList(connection), DefaultSettings(connection)};
+}
+
+bool nsPrinterCUPS::Supports(const char* aOption, const char* aValue) const {
+  PrinterInfoLock lock = TryEnsurePrinterInfo();
+  return mShim.cupsCheckDestSupported(CUPS_HTTP_DEFAULT, lock->mPrinter,
+                                      lock->mPrinterInfo, aOption, aValue);
+}
+
+bool nsPrinterCUPS::IsCUPSVersionAtLeast(uint64_t aCUPSMajor,
+                                         uint64_t aCUPSMinor,
+                                         uint64_t aCUPSPatch) const {
+  PrinterInfoLock lock = TryEnsurePrinterInfo();
+  // Compare major version.
+  if (lock->mCUPSMajor > aCUPSMajor) {
+    return true;
+  }
+  if (lock->mCUPSMajor < aCUPSMajor) {
+    return false;
+  }
+
+  // Compare minor version.
+  if (lock->mCUPSMinor > aCUPSMinor) {
+    return true;
+  }
+  if (lock->mCUPSMinor < aCUPSMinor) {
+    return false;
+  }
+
+  // Compare patch.
+  return aCUPSPatch <= lock->mCUPSPatch;
+}
+
+http_t* nsPrinterCUPS::Connection::GetConnection(cups_dest_t* aDest) {
+  if (mWasInited) {
+    return mConnection;
+  }
+  mWasInited = true;
+
+  // blocking call
+  http_t* const connection = mShim.cupsConnectDest(aDest, CUPS_DEST_FLAGS_NONE,
+                                                   /* timeout(ms) */ 5000,
+                                                   /* cancel */ nullptr,
+                                                   /* resource */ nullptr,
+                                                   /* resourcesize */ 0,
+                                                   /* callback */ nullptr,
+                                                   /* user_data */ nullptr);
+  if (connection) {
+    mConnection = connection;
+  }
+  return mConnection;
+}
+
+nsPrinterCUPS::Connection::~Connection() {
+  if (mWasInited && mConnection) {
+    mShim.httpClose(mConnection);
+  }
+}
+
+PrintSettingsInitializer nsPrinterCUPS::DefaultSettings(
+    Connection& aConnection) const {
+  nsString printerName;
+  GetPrinterName(printerName);
+  PrinterInfoLock lock = TryEnsurePrinterInfo();
+
+  cups_size_t media;
+
+  bool hasDefaultMedia = false;
+// cupsGetDestMediaDefault appears to return more accurate defaults on macOS,
+// and the IPP attribute appears to return more accurate defaults on Linux.
+#ifdef XP_MACOSX
+  hasDefaultMedia = mShim.cupsGetDestMediaDefault(
+      CUPS_HTTP_DEFAULT, lock->mPrinter, lock->mPrinterInfo,
+      CUPS_MEDIA_FLAGS_DEFAULT, &media);
+#else
+  {
+    ipp_attribute_t* defaultMediaIPP =
+        mShim.cupsFindDestDefault
+            ? mShim.cupsFindDestDefault(CUPS_HTTP_DEFAULT, lock->mPrinter,
+                                        lock->mPrinterInfo, "media")
+            : nullptr;
+
+    const char* defaultMediaName =
+        defaultMediaIPP ? mShim.ippGetString(defaultMediaIPP, 0, nullptr)
+                        : nullptr;
+
+    hasDefaultMedia = defaultMediaName &&
+                      mShim.cupsGetDestMediaByName(
+                          CUPS_HTTP_DEFAULT, lock->mPrinter, lock->mPrinterInfo,
+                          defaultMediaName, CUPS_MEDIA_FLAGS_DEFAULT, &media);
+  }
+#endif
+
+  if (!hasDefaultMedia) {
+    return PrintSettingsInitializer{
+        std::move(printerName),
+        PaperInfo(),
+        SupportsColor(),
+    };
+  }
+
+  // Check if this is a localized fallback paper size, in which case we can
+  // avoid using the CUPS localization methods.
+  const gfx::SizeDouble sizeDouble{
+      media.width * kPointsPerHundredthMillimeter,
+      media.length * kPointsPerHundredthMillimeter};
+  if (const PaperInfo* const paperInfo = FindCommonPaperSize(sizeDouble)) {
+    return PrintSettingsInitializer{
+        std::move(printerName),
+        MakePaperInfo(paperInfo->mName, media),
+        SupportsColor(),
+    };
+  }
+
+  http_t* const connection = aConnection.GetConnection(lock->mPrinter);
+  // XXX Do we actually have the guarantee that this is utf-8?
+  NS_ConvertUTF8toUTF16 localizedName{
+      connection ? LocalizeMediaName(*connection, media) : ""};
+
+  return PrintSettingsInitializer{
+      std::move(printerName),
+      MakePaperInfo(localizedName, media),
+      SupportsColor(),
+  };
+}
+
+nsTArray<mozilla::PaperInfo> nsPrinterCUPS::PaperList(
+    Connection& aConnection) const {
+  PrinterInfoLock lock = mPrinterInfoMutex.Lock();
+  http_t* const connection = aConnection.GetConnection(lock->mPrinter);
+  TryEnsurePrinterInfo(lock, connection);
+
+  if (!lock->mPrinterInfo) {
+    return {};
+  }
+
+  const int paperCount = mShim.cupsGetDestMediaCount
+                             ? mShim.cupsGetDestMediaCount(
+                                   connection, lock->mPrinter,
+                                   lock->mPrinterInfo, CUPS_MEDIA_FLAGS_DEFAULT)
+                             : 0;
+  nsTArray<PaperInfo> paperList;
+  nsTHashtable<nsCharPtrHashKey> paperSet(std::max(paperCount, 0));
+
+  paperList.SetCapacity(paperCount);
+  for (int i = 0; i < paperCount; ++i) {
+    cups_size_t media;
+    const int getInfoSucceeded = mShim.cupsGetDestMediaByIndex(
+        connection, lock->mPrinter, lock->mPrinterInfo, i,
+        CUPS_MEDIA_FLAGS_DEFAULT, &media);
+
+    if (!getInfoSucceeded || !paperSet.EnsureInserted(media.media)) {
+      continue;
+    }
+    // Check if this is a PWG paper size, in which case we can avoid using the
+    // CUPS localization methods.
+    const gfx::SizeDouble sizeDouble{
+        media.width * kPointsPerHundredthMillimeter,
+        media.length * kPointsPerHundredthMillimeter};
+    if (const PaperInfo* const paperInfo = FindCommonPaperSize(sizeDouble)) {
+      paperList.AppendElement(MakePaperInfo(paperInfo->mName, media));
+    } else {
+      const char* const mediaName =
+          connection ? LocalizeMediaName(*connection, media) : media.media;
+      paperList.AppendElement(
+          MakePaperInfo(NS_ConvertUTF8toUTF16(mediaName), media));
+    }
+  }
+
+  return paperList;
+}
+
+void nsPrinterCUPS::TryEnsurePrinterInfo(PrinterInfoLock& aLock,
+                                         http_t* const aConnection) const {
+  if (aLock->mPrinterInfo ||
+      (aConnection == CUPS_HTTP_DEFAULT ? aLock->mTriedInitWithDefault
+                                        : aLock->mTriedInitWithConnection)) {
+    return;
+  }
+
+  if (aConnection == CUPS_HTTP_DEFAULT) {
+    aLock->mTriedInitWithDefault = true;
+  } else {
+    aLock->mTriedInitWithConnection = true;
+  }
+
+  MOZ_ASSERT(aLock->mPrinter);
+
+  // httpGetAddress was only added in CUPS 2.0, and some systems still use
+  // CUPS 1.7.
+  if (aConnection && MOZ_LIKELY(mShim.httpGetAddress && mShim.httpAddrPort)) {
+    // This is a workaround for the CUPS Bug seen in bug 1691347.
+    // This is to avoid a null string being passed to strstr in CUPS. The path
+    // in CUPS that leads to this is as follows:
+    //
+    // In cupsCopyDestInfo, CUPS_DEST_FLAG_DEVICE is set when the connection is
+    // not null (same as CUPS_HTTP_DEFAULT), the print server is not the same
+    // as our hostname and is not path-based (starts with a '/'), or the IPP
+    // port is different than the global server IPP port.
+    //
+    // https://github.com/apple/cups/blob/c9da6f63b263faef5d50592fe8cf8056e0a58aa2/cups/dest-options.c#L718-L722
+    //
+    // In _cupsGetDestResource, CUPS fetches the IPP options "device-uri" and
+    // "printer-uri-supported". Note that IPP options are returned as null when
+    // missing.
+    //
+    // https://github.com/apple/cups/blob/23c45db76a8520fd6c3b1d9164dbe312f1ab1481/cups/dest.c#L1138-L1141
+    //
+    // If the CUPS_DEST_FLAG_DEVICE is set or the "printer-uri-supported"
+    // option is not set, CUPS checks for "._tcp" in the "device-uri" option
+    // without doing a NULL-check first.
+    //
+    // https://github.com/apple/cups/blob/23c45db76a8520fd6c3b1d9164dbe312f1ab1481/cups/dest.c#L1144
+    //
+    // If we find that those branches will be taken, don't actually fetch the
+    // CUPS data and instead just return an empty printer info.
+
+    const char* const serverNameBytes = mShim.cupsServer();
+
+    if (MOZ_LIKELY(serverNameBytes)) {
+      const nsDependentCString serverName{serverNameBytes};
+
+      // We only need enough characters to determine equality with serverName.
+      // + 2 because we need one byte for the null-character, and we also want
+      // to get more characters of the host name than the server name if
+      // possible. Otherwise, if the hostname starts with the same text as the
+      // entire server name, it would compare equal when it's not.
+      const size_t hostnameMemLength = serverName.Length() + 2;
+      auto hostnameMem = MakeUnique<char[]>(hostnameMemLength);
+
+      // We don't expect httpGetHostname to return null when a connection is
+      // passed, but it's better not to make assumptions.
+      const char* const hostnameBytes = mShim.httpGetHostname(
+          aConnection, hostnameMem.get(), hostnameMemLength);
+
+      if (MOZ_LIKELY(hostnameBytes)) {
+        const nsDependentCString hostname{hostnameBytes};
+
+        // Attempt to match the condional at
+        // https://github.com/apple/cups/blob/c9da6f63b263faef5d50592fe8cf8056e0a58aa2/cups/dest-options.c#L718
+        //
+        // To find the result of the comparison CUPS performs of
+        // `strcmp(http->hostname, cg->server)`, we use httpGetHostname to try
+        // to get the value of `http->hostname`, but this isn't quite the same.
+        // For local addresses, httpGetHostName will normalize the result to be
+        // localhost", rather than the actual value of `http->hostname`.
+        //
+        // https://github.com/apple/cups/blob/2201569857f225c9874bfae19713ffb2f4bdfdeb/cups/http-addr.c#L794-L818
+        //
+        // Because of this, if both serverName and hostname equal "localhost",
+        // then the actual hostname might be a different local address that CUPS
+        // normalized in httpGetHostName, and `http->hostname` won't be equal to
+        // `cg->server` in CUPS.
+        const bool namesMightNotMatch =
+            hostname != serverName || hostname == "localhost";
+        const bool portsDiffer =
+            mShim.httpAddrPort(mShim.httpGetAddress(aConnection)) !=
+            mShim.ippPort();
+        const bool cupsDestDeviceFlag =
+            (namesMightNotMatch && serverName[0] != '/') || portsDiffer;
+
+        // Match the conditional at
+        // https://github.com/apple/cups/blob/23c45db76a8520fd6c3b1d9164dbe312f1ab1481/cups/dest.c#L1144
+        // but if device-uri is null do not call into CUPS.
+        if ((cupsDestDeviceFlag ||
+             !FindCUPSOption(aLock, "printer-uri-supported")) &&
+            !FindCUPSOption(aLock, "device-uri")) {
+          return;
+        }
+      }
+    }
+  }
+
+  // All CUPS calls that take the printer info do null-checks internally, so we
+  // can fetch this info and only worry about the result of the later CUPS
+  // functions.
+  aLock->mPrinterInfo = mShim.cupsCopyDestInfo(aConnection, aLock->mPrinter);
+
+  // Even if we failed to fetch printer info, it is still possible we can talk
+  // to the print server and get its CUPS version.
+  FetchCUPSVersionForPrinter(mShim, aLock->mPrinter, aLock->mCUPSMajor,
+                             aLock->mCUPSMinor, aLock->mCUPSPatch);
+}
+
+void nsPrinterCUPS::ForEachExtraMonochromeSetting(
+    FunctionRef<void(const nsACString&, const nsACString&)> aCallback) {
+  nsAutoCString pref;
+  Preferences::GetCString("print.cups.monochrome.extra_settings", pref);
+  if (pref.IsEmpty()) {
+    return;
+  }
+
+  for (const auto& pair : pref.Split(',')) {
+    auto splitter = pair.Split(':');
+    auto end = splitter.end();
+
+    auto key = splitter.begin();
+    if (key == end) {
+      continue;
+    }
+
+    auto value = ++splitter.begin();
+    if (value == end) {
+      continue;
+    }
+
+    aCallback(*key, *value);
+  }
+}