Source code
Revision control
Copy as Markdown
Other Tools
/* -*- 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
#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.
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.
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 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.
//
//
// 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.
//
//
// 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`.
//
//
// 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
// 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);
}
}