|
|
/*
|
|
|
* Printer routines for the CUPS scheduler.
|
|
|
*
|
|
|
* Copyright © 2007-2019 by Apple Inc.
|
|
|
* Copyright © 1997-2007 by Easy Software Products, all rights reserved.
|
|
|
*
|
|
|
* Licensed under Apache License v2.0. See the file "LICENSE" for more
|
|
|
* information.
|
|
|
*/
|
|
|
|
|
|
/*
|
|
|
* Include necessary headers...
|
|
|
*/
|
|
|
|
|
|
#include "cupsd.h"
|
|
|
#include <cups/dir.h>
|
|
|
#ifdef HAVE_APPLICATIONSERVICES_H
|
|
|
# include <ApplicationServices/ApplicationServices.h>
|
|
|
#endif /* HAVE_APPLICATIONSERVICES_H */
|
|
|
#ifdef HAVE_SYS_MOUNT_H
|
|
|
# include <sys/mount.h>
|
|
|
#endif /* HAVE_SYS_MOUNT_H */
|
|
|
#ifdef HAVE_SYS_STATVFS_H
|
|
|
# include <sys/statvfs.h>
|
|
|
#elif defined(HAVE_SYS_STATFS_H)
|
|
|
# include <sys/statfs.h>
|
|
|
#endif /* HAVE_SYS_STATVFS_H */
|
|
|
#ifdef HAVE_SYS_VFS_H
|
|
|
# include <sys/vfs.h>
|
|
|
#endif /* HAVE_SYS_VFS_H */
|
|
|
#ifdef __APPLE__
|
|
|
# include <asl.h>
|
|
|
#endif /* __APPLE__ */
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Local functions...
|
|
|
*/
|
|
|
|
|
|
static void add_printer_defaults(cupsd_printer_t *p);
|
|
|
static void add_printer_filter(cupsd_printer_t *p, mime_type_t *type,
|
|
|
const char *filter);
|
|
|
static void add_printer_formats(cupsd_printer_t *p);
|
|
|
static int compare_printers(void *first, void *second, void *data);
|
|
|
static void delete_printer_filters(cupsd_printer_t *p);
|
|
|
static void dirty_printer(cupsd_printer_t *p);
|
|
|
static void load_ppd(cupsd_printer_t *p);
|
|
|
static ipp_t *new_media_col(pwg_size_t *size);
|
|
|
static void write_xml_string(cups_file_t *fp, const char *s);
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdAddPrinter()' - Add a printer to the system.
|
|
|
*/
|
|
|
|
|
|
cupsd_printer_t * /* O - New printer */
|
|
|
cupsdAddPrinter(const char *name) /* I - Name of printer */
|
|
|
{
|
|
|
cupsd_printer_t *p; /* New printer */
|
|
|
char uri[1024], /* Printer URI */
|
|
|
uuid[64]; /* Printer UUID */
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Range check input...
|
|
|
*/
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdAddPrinter(\"%s\")", name);
|
|
|
|
|
|
/*
|
|
|
* Create a new printer entity...
|
|
|
*/
|
|
|
|
|
|
if ((p = calloc(1, sizeof(cupsd_printer_t))) == NULL)
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_CRIT, "Unable to allocate memory for printer - %s",
|
|
|
strerror(errno));
|
|
|
return (NULL);
|
|
|
}
|
|
|
|
|
|
_cupsRWInit(&p->lock);
|
|
|
|
|
|
cupsdSetString(&p->name, name);
|
|
|
cupsdSetString(&p->info, name);
|
|
|
cupsdSetString(&p->hostname, ServerName);
|
|
|
|
|
|
httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
|
|
|
ServerName, RemotePort, "/printers/%s", name);
|
|
|
cupsdSetString(&p->uri, uri);
|
|
|
cupsdSetString(&p->uuid, httpAssembleUUID(ServerName, RemotePort, name, 0,
|
|
|
uuid, sizeof(uuid)));
|
|
|
cupsdSetDeviceURI(p, "file:///dev/null");
|
|
|
|
|
|
p->config_time = time(NULL);
|
|
|
p->state = IPP_PRINTER_STOPPED;
|
|
|
p->state_time = time(NULL);
|
|
|
p->accepting = 0;
|
|
|
p->shared = DefaultShared;
|
|
|
p->filetype = mimeAddType(MimeDatabase, "printer", name);
|
|
|
|
|
|
cupsdSetString(&p->job_sheets[0], "none");
|
|
|
cupsdSetString(&p->job_sheets[1], "none");
|
|
|
|
|
|
cupsdSetString(&p->error_policy, ErrorPolicy);
|
|
|
cupsdSetString(&p->op_policy, DefaultPolicy);
|
|
|
|
|
|
p->op_policy_ptr = DefaultPolicyPtr;
|
|
|
|
|
|
/*
|
|
|
* Insert the printer in the printer list alphabetically...
|
|
|
*/
|
|
|
|
|
|
if (!Printers)
|
|
|
Printers = cupsArrayNew(compare_printers, NULL);
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2,
|
|
|
"cupsdAddPrinter: Adding %s to Printers", p->name);
|
|
|
cupsArrayAdd(Printers, p);
|
|
|
|
|
|
/*
|
|
|
* Return the new printer...
|
|
|
*/
|
|
|
|
|
|
return (p);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdCreateCommonData()' - Create the common printer data.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdCreateCommonData(void)
|
|
|
{
|
|
|
int i; /* Looping var */
|
|
|
ipp_attribute_t *attr; /* Attribute data */
|
|
|
cups_dir_t *dir; /* Notifier directory */
|
|
|
cups_dentry_t *dent; /* Notifier directory entry */
|
|
|
cups_array_t *notifiers; /* Notifier array */
|
|
|
char filename[1024], /* Filename */
|
|
|
*notifier; /* Current notifier */
|
|
|
cupsd_policy_t *p; /* Current policy */
|
|
|
int k_supported; /* Maximum file size supported */
|
|
|
#ifdef HAVE_STATVFS
|
|
|
struct statvfs spoolinfo; /* FS info for spool directory */
|
|
|
double spoolsize; /* FS size */
|
|
|
#elif defined(HAVE_STATFS)
|
|
|
struct statfs spoolinfo; /* FS info for spool directory */
|
|
|
double spoolsize; /* FS size */
|
|
|
#endif /* HAVE_STATVFS */
|
|
|
static const char * const page_delivery[] =
|
|
|
{ /* page-delivery-supported values */
|
|
|
"reverse-order",
|
|
|
"same-order"
|
|
|
};
|
|
|
static const char * const print_scaling[] =
|
|
|
{ /* print-scaling-supported values */
|
|
|
"auto",
|
|
|
"auto-fit",
|
|
|
"fill",
|
|
|
"fit",
|
|
|
"none"
|
|
|
};
|
|
|
static const int number_up[] = /* number-up-supported values */
|
|
|
{ 1, 2, 4, 6, 9, 16 };
|
|
|
static const char * const number_up_layout[] =
|
|
|
{ /* number-up-layout-supported values */
|
|
|
"btlr",
|
|
|
"btrl",
|
|
|
"lrbt",
|
|
|
"lrtb",
|
|
|
"rlbt",
|
|
|
"rltb",
|
|
|
"tblr",
|
|
|
"tbrl"
|
|
|
};
|
|
|
static const int orients[4] =/* orientation-requested-supported values */
|
|
|
{
|
|
|
IPP_PORTRAIT,
|
|
|
IPP_LANDSCAPE,
|
|
|
IPP_REVERSE_LANDSCAPE,
|
|
|
IPP_REVERSE_PORTRAIT
|
|
|
};
|
|
|
static const char * const holds[] = /* job-hold-until-supported values */
|
|
|
{
|
|
|
"no-hold",
|
|
|
"indefinite",
|
|
|
"day-time",
|
|
|
"evening",
|
|
|
"night",
|
|
|
"second-shift",
|
|
|
"third-shift",
|
|
|
"weekend"
|
|
|
};
|
|
|
static const char * const features[] =/* ipp-features-supported values */
|
|
|
{
|
|
|
"subscription-object"
|
|
|
};
|
|
|
static const char * const versions[] =/* ipp-versions-supported values */
|
|
|
{
|
|
|
"1.0",
|
|
|
"1.1",
|
|
|
"2.0",
|
|
|
"2.1"
|
|
|
};
|
|
|
static const int ops[] = /* operations-supported values */
|
|
|
{
|
|
|
IPP_OP_PRINT_JOB,
|
|
|
IPP_OP_VALIDATE_JOB,
|
|
|
IPP_OP_CREATE_JOB,
|
|
|
IPP_OP_SEND_DOCUMENT,
|
|
|
IPP_OP_CANCEL_JOB,
|
|
|
IPP_OP_GET_JOB_ATTRIBUTES,
|
|
|
IPP_OP_GET_JOBS,
|
|
|
IPP_OP_GET_PRINTER_ATTRIBUTES,
|
|
|
IPP_OP_HOLD_JOB,
|
|
|
IPP_OP_RELEASE_JOB,
|
|
|
IPP_OP_PAUSE_PRINTER,
|
|
|
IPP_OP_RESUME_PRINTER,
|
|
|
IPP_OP_PURGE_JOBS,
|
|
|
IPP_OP_SET_PRINTER_ATTRIBUTES,
|
|
|
IPP_OP_SET_JOB_ATTRIBUTES,
|
|
|
IPP_OP_GET_PRINTER_SUPPORTED_VALUES,
|
|
|
IPP_OP_CREATE_PRINTER_SUBSCRIPTIONS,
|
|
|
IPP_OP_CREATE_JOB_SUBSCRIPTIONS,
|
|
|
IPP_OP_GET_SUBSCRIPTION_ATTRIBUTES,
|
|
|
IPP_OP_GET_SUBSCRIPTIONS,
|
|
|
IPP_OP_RENEW_SUBSCRIPTION,
|
|
|
IPP_OP_CANCEL_SUBSCRIPTION,
|
|
|
IPP_OP_GET_NOTIFICATIONS,
|
|
|
IPP_OP_ENABLE_PRINTER,
|
|
|
IPP_OP_DISABLE_PRINTER,
|
|
|
IPP_OP_HOLD_NEW_JOBS,
|
|
|
IPP_OP_RELEASE_HELD_NEW_JOBS,
|
|
|
IPP_OP_CANCEL_JOBS,
|
|
|
IPP_OP_CANCEL_MY_JOBS,
|
|
|
IPP_OP_CLOSE_JOB,
|
|
|
IPP_OP_CUPS_GET_DEFAULT,
|
|
|
IPP_OP_CUPS_GET_PRINTERS,
|
|
|
IPP_OP_CUPS_ADD_MODIFY_PRINTER,
|
|
|
IPP_OP_CUPS_DELETE_PRINTER,
|
|
|
IPP_OP_CUPS_GET_CLASSES,
|
|
|
IPP_OP_CUPS_ADD_MODIFY_CLASS,
|
|
|
IPP_OP_CUPS_DELETE_CLASS,
|
|
|
IPP_OP_CUPS_ACCEPT_JOBS,
|
|
|
IPP_OP_CUPS_REJECT_JOBS,
|
|
|
IPP_OP_CUPS_SET_DEFAULT,
|
|
|
IPP_OP_CUPS_GET_DEVICES,
|
|
|
IPP_OP_CUPS_GET_PPDS,
|
|
|
IPP_OP_CUPS_MOVE_JOB,
|
|
|
IPP_OP_CUPS_AUTHENTICATE_JOB,
|
|
|
IPP_OP_CUPS_GET_PPD,
|
|
|
IPP_OP_CUPS_GET_DOCUMENT,
|
|
|
IPP_OP_RESTART_JOB
|
|
|
};
|
|
|
static const char * const charsets[] =/* charset-supported values */
|
|
|
{
|
|
|
"us-ascii",
|
|
|
"utf-8"
|
|
|
};
|
|
|
static const char * const compressions[] =
|
|
|
{ /* document-compression-supported values */
|
|
|
"none"
|
|
|
#ifdef HAVE_LIBZ
|
|
|
,"gzip"
|
|
|
#endif /* HAVE_LIBZ */
|
|
|
};
|
|
|
static const char * const media_col_supported[] =
|
|
|
{ /* media-col-supported values */
|
|
|
"media-bottom-margin",
|
|
|
"media-left-margin",
|
|
|
"media-right-margin",
|
|
|
"media-size",
|
|
|
"media-source",
|
|
|
"media-top-margin",
|
|
|
"media-type"
|
|
|
};
|
|
|
static const char * const multiple_document_handling[] =
|
|
|
{ /* multiple-document-handling-supported values */
|
|
|
"separate-documents-uncollated-copies",
|
|
|
"separate-documents-collated-copies"
|
|
|
};
|
|
|
static const char * const notify_attrs[] =
|
|
|
{ /* notify-attributes-supported values */
|
|
|
"printer-state-change-time",
|
|
|
"notify-lease-expiration-time",
|
|
|
"notify-subscriber-user-name"
|
|
|
};
|
|
|
static const char * const notify_events[] =
|
|
|
{ /* notify-events-supported values */
|
|
|
"job-completed",
|
|
|
"job-config-changed",
|
|
|
"job-created",
|
|
|
"job-progress",
|
|
|
"job-state-changed",
|
|
|
"job-stopped",
|
|
|
"printer-added",
|
|
|
"printer-changed",
|
|
|
"printer-config-changed",
|
|
|
"printer-deleted",
|
|
|
"printer-finishings-changed",
|
|
|
"printer-media-changed",
|
|
|
"printer-modified",
|
|
|
"printer-restarted",
|
|
|
"printer-shutdown",
|
|
|
"printer-state-changed",
|
|
|
"printer-stopped",
|
|
|
"server-audit",
|
|
|
"server-restarted",
|
|
|
"server-started",
|
|
|
"server-stopped"
|
|
|
};
|
|
|
static const char * const job_creation[] =
|
|
|
{ /* job-creation-attributes-supported */
|
|
|
"copies",
|
|
|
"finishings",
|
|
|
"finishings-col",
|
|
|
"ipp-attribute-fidelity",
|
|
|
"job-hold-until",
|
|
|
"job-name",
|
|
|
"job-priority",
|
|
|
"job-sheets",
|
|
|
"media",
|
|
|
"media-col",
|
|
|
"multiple-document-handling",
|
|
|
"number-up",
|
|
|
"number-up-layout",
|
|
|
"orientation-requested",
|
|
|
"output-bin",
|
|
|
"page-delivery",
|
|
|
"page-ranges",
|
|
|
"print-color-mode",
|
|
|
"print-quality",
|
|
|
"print-scaling",
|
|
|
"printer-resolution",
|
|
|
"sides"
|
|
|
};
|
|
|
static const char * const job_settable[] =
|
|
|
{ /* job-settable-attributes-supported */
|
|
|
"copies",
|
|
|
"finishings",
|
|
|
"job-hold-until",
|
|
|
"job-name",
|
|
|
"job-priority",
|
|
|
"media",
|
|
|
"media-col",
|
|
|
"multiple-document-handling",
|
|
|
"number-up",
|
|
|
"output-bin",
|
|
|
"orientation-requested",
|
|
|
"page-ranges",
|
|
|
"print-color-mode",
|
|
|
"print-quality",
|
|
|
"printer-resolution",
|
|
|
"sides"
|
|
|
};
|
|
|
static const char * const pdf_versions[] =
|
|
|
{ /* pdf-versions-supported */
|
|
|
"adobe-1.2",
|
|
|
"adobe-1.3",
|
|
|
"adobe-1.4",
|
|
|
"adobe-1.5",
|
|
|
"adobe-1.6",
|
|
|
"adobe-1.7",
|
|
|
"iso-19005-1_2005",
|
|
|
"iso-32000-1_2008",
|
|
|
"pwg-5102.3"
|
|
|
};
|
|
|
static const char * const printer_settable[] =
|
|
|
{ /* printer-settable-attributes-supported */
|
|
|
"printer-geo-location",
|
|
|
"printer-info",
|
|
|
"printer-location",
|
|
|
"printer-organization",
|
|
|
"printer-organizational-unit"
|
|
|
};
|
|
|
static const char * const which_jobs[] =
|
|
|
{ /* which-jobs-supported values */
|
|
|
"completed",
|
|
|
"not-completed",
|
|
|
"aborted",
|
|
|
"all",
|
|
|
"canceled",
|
|
|
"pending",
|
|
|
"pending-held",
|
|
|
"processing",
|
|
|
"processing-stopped"
|
|
|
};
|
|
|
|
|
|
|
|
|
if (CommonData)
|
|
|
ippDelete(CommonData);
|
|
|
|
|
|
CommonData = ippNew();
|
|
|
|
|
|
/*
|
|
|
* Get the maximum spool size based on the size of the filesystem used for
|
|
|
* the RequestRoot directory. If the host OS doesn't support the statfs call
|
|
|
* or the filesystem is larger than 2TiB, always report INT_MAX.
|
|
|
*/
|
|
|
|
|
|
#ifdef HAVE_STATVFS
|
|
|
if (statvfs(RequestRoot, &spoolinfo))
|
|
|
k_supported = INT_MAX;
|
|
|
else if ((spoolsize = (double)spoolinfo.f_frsize * spoolinfo.f_blocks / 1024) >
|
|
|
INT_MAX)
|
|
|
k_supported = INT_MAX;
|
|
|
else
|
|
|
k_supported = (int)spoolsize;
|
|
|
|
|
|
#elif defined(HAVE_STATFS)
|
|
|
if (statfs(RequestRoot, &spoolinfo))
|
|
|
k_supported = INT_MAX;
|
|
|
else if ((spoolsize = (double)spoolinfo.f_bsize * spoolinfo.f_blocks / 1024) >
|
|
|
INT_MAX)
|
|
|
k_supported = INT_MAX;
|
|
|
else
|
|
|
k_supported = (int)spoolsize;
|
|
|
|
|
|
#else
|
|
|
k_supported = INT_MAX;
|
|
|
#endif /* HAVE_STATVFS */
|
|
|
|
|
|
/*
|
|
|
* This list of attributes is sorted to improve performance when the
|
|
|
* client provides a requested-attributes attribute...
|
|
|
*/
|
|
|
|
|
|
/* charset-configured */
|
|
|
ippAddString(CommonData, IPP_TAG_PRINTER, IPP_TAG_CHARSET | IPP_TAG_COPY,
|
|
|
"charset-configured", NULL, "utf-8");
|
|
|
|
|
|
/* charset-supported */
|
|
|
ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_CHARSET | IPP_TAG_COPY,
|
|
|
"charset-supported", sizeof(charsets) / sizeof(charsets[0]),
|
|
|
NULL, charsets);
|
|
|
|
|
|
/* compression-supported */
|
|
|
ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD | IPP_TAG_COPY,
|
|
|
"compression-supported",
|
|
|
sizeof(compressions) / sizeof(compressions[0]),
|
|
|
NULL, compressions);
|
|
|
|
|
|
/* copies-supported */
|
|
|
ippAddRange(CommonData, IPP_TAG_PRINTER, "copies-supported", 1, MaxCopies);
|
|
|
|
|
|
/* cups-version */
|
|
|
ippAddString(CommonData, IPP_TAG_PRINTER, IPP_TAG_TEXT | IPP_TAG_COPY,
|
|
|
"cups-version", NULL, &CUPS_SVERSION[6]);
|
|
|
|
|
|
/* generated-natural-language-supported (no IPP_TAG_COPY) */
|
|
|
ippAddString(CommonData, IPP_TAG_PRINTER, IPP_TAG_LANGUAGE,
|
|
|
"generated-natural-language-supported", NULL, DefaultLanguage);
|
|
|
|
|
|
/* ipp-features-supported */
|
|
|
ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_CONST_TAG(IPP_TAG_KEYWORD), "ipp-features-supported", sizeof(features) / sizeof(features[0]), NULL, features);
|
|
|
|
|
|
/* ipp-versions-supported */
|
|
|
ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD | IPP_TAG_COPY,
|
|
|
"ipp-versions-supported", sizeof(versions) / sizeof(versions[0]),
|
|
|
NULL, versions);
|
|
|
|
|
|
/* ippget-event-life */
|
|
|
ippAddInteger(CommonData, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
|
|
|
"ippget-event-life", 15);
|
|
|
|
|
|
/* job-cancel-after-supported */
|
|
|
ippAddRange(CommonData, IPP_TAG_PRINTER, "job-cancel-after-supported",
|
|
|
0, INT_MAX);
|
|
|
|
|
|
/* job-creation-attributes-supported */
|
|
|
ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD | IPP_TAG_COPY,
|
|
|
"job-creation-attributes-supported",
|
|
|
sizeof(job_creation) / sizeof(job_creation[0]),
|
|
|
NULL, job_creation);
|
|
|
|
|
|
/* job-hold-until-supported */
|
|
|
ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD | IPP_TAG_COPY,
|
|
|
"job-hold-until-supported", sizeof(holds) / sizeof(holds[0]),
|
|
|
NULL, holds);
|
|
|
|
|
|
/* job-ids-supported */
|
|
|
ippAddBoolean(CommonData, IPP_TAG_PRINTER, "job-ids-supported", 1);
|
|
|
|
|
|
/* job-k-octets-supported */
|
|
|
ippAddRange(CommonData, IPP_TAG_PRINTER, "job-k-octets-supported", 0,
|
|
|
k_supported);
|
|
|
|
|
|
/* job-priority-supported */
|
|
|
ippAddInteger(CommonData, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
|
|
|
"job-priority-supported", 100);
|
|
|
|
|
|
/* job-settable-attributes-supported */
|
|
|
ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD | IPP_TAG_COPY,
|
|
|
"job-settable-attributes-supported",
|
|
|
sizeof(job_settable) / sizeof(job_settable[0]),
|
|
|
NULL, job_settable);
|
|
|
|
|
|
/* job-sheets-supported */
|
|
|
if (cupsArrayCount(Banners) > 0)
|
|
|
{
|
|
|
/*
|
|
|
* Setup the job-sheets-supported attribute...
|
|
|
*/
|
|
|
|
|
|
if (Classification && !ClassifyOverride)
|
|
|
attr = ippAddString(CommonData, IPP_TAG_PRINTER,
|
|
|
IPP_TAG_NAME | IPP_TAG_COPY,
|
|
|
"job-sheets-supported", NULL, Classification);
|
|
|
else
|
|
|
attr = ippAddStrings(CommonData, IPP_TAG_PRINTER,
|
|
|
IPP_TAG_NAME | IPP_TAG_COPY,
|
|
|
"job-sheets-supported", cupsArrayCount(Banners) + 1,
|
|
|
NULL, NULL);
|
|
|
|
|
|
if (attr == NULL)
|
|
|
cupsdLogMessage(CUPSD_LOG_EMERG,
|
|
|
"Unable to allocate memory for "
|
|
|
"job-sheets-supported attribute: %s!", strerror(errno));
|
|
|
else if (!Classification || ClassifyOverride)
|
|
|
{
|
|
|
cupsd_banner_t *banner; /* Current banner */
|
|
|
|
|
|
|
|
|
attr->values[0].string.text = _cupsStrAlloc("none");
|
|
|
|
|
|
for (i = 1, banner = (cupsd_banner_t *)cupsArrayFirst(Banners);
|
|
|
banner;
|
|
|
i ++, banner = (cupsd_banner_t *)cupsArrayNext(Banners))
|
|
|
attr->values[i].string.text = banner->name;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
ippAddString(CommonData, IPP_TAG_PRINTER, IPP_TAG_NAME | IPP_TAG_COPY,
|
|
|
"job-sheets-supported", NULL, "none");
|
|
|
|
|
|
/* jpeg-k-octets-supported */
|
|
|
ippAddRange(CommonData, IPP_TAG_PRINTER, "jpeg-k-octets-supported", 0,
|
|
|
k_supported);
|
|
|
|
|
|
/* jpeg-x-dimension-supported */
|
|
|
ippAddRange(CommonData, IPP_TAG_PRINTER, "jpeg-x-dimension-supported", 0,
|
|
|
65535);
|
|
|
|
|
|
/* jpeg-y-dimension-supported */
|
|
|
ippAddRange(CommonData, IPP_TAG_PRINTER, "jpeg-y-dimension-supported", 1,
|
|
|
65535);
|
|
|
|
|
|
/* media-col-supported */
|
|
|
ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD | IPP_TAG_COPY,
|
|
|
"media-col-supported",
|
|
|
sizeof(media_col_supported) /
|
|
|
sizeof(media_col_supported[0]), NULL,
|
|
|
media_col_supported);
|
|
|
|
|
|
/* multiple-document-handling-supported */
|
|
|
ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD | IPP_TAG_COPY,
|
|
|
"multiple-document-handling-supported",
|
|
|
sizeof(multiple_document_handling) /
|
|
|
sizeof(multiple_document_handling[0]), NULL,
|
|
|
multiple_document_handling);
|
|
|
|
|
|
/* multiple-document-jobs-supported */
|
|
|
ippAddBoolean(CommonData, IPP_TAG_PRINTER,
|
|
|
"multiple-document-jobs-supported", 1);
|
|
|
|
|
|
/* multiple-operation-time-out */
|
|
|
ippAddInteger(CommonData, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
|
|
|
"multiple-operation-time-out", MultipleOperationTimeout);
|
|
|
|
|
|
/* multiple-operation-time-out-action */
|
|
|
ippAddString(CommonData, IPP_TAG_PRINTER, IPP_CONST_TAG(IPP_TAG_KEYWORD), "multiple-operation-time-out-action", NULL, "process-job");
|
|
|
|
|
|
/* natural-language-configured (no IPP_TAG_COPY) */
|
|
|
ippAddString(CommonData, IPP_TAG_PRINTER, IPP_TAG_LANGUAGE,
|
|
|
"natural-language-configured", NULL, DefaultLanguage);
|
|
|
|
|
|
/* notify-attributes-supported */
|
|
|
ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD | IPP_TAG_COPY,
|
|
|
"notify-attributes-supported",
|
|
|
(int)(sizeof(notify_attrs) / sizeof(notify_attrs[0])),
|
|
|
NULL, notify_attrs);
|
|
|
|
|
|
/* notify-lease-duration-supported */
|
|
|
ippAddRange(CommonData, IPP_TAG_PRINTER,
|
|
|
"notify-lease-duration-supported", 0,
|
|
|
MaxLeaseDuration ? MaxLeaseDuration : 2147483647);
|
|
|
|
|
|
/* notify-max-events-supported */
|
|
|
ippAddInteger(CommonData, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
|
|
|
"notify-max-events-supported", MaxEvents);
|
|
|
|
|
|
/* notify-events-supported */
|
|
|
ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD | IPP_TAG_COPY,
|
|
|
"notify-events-supported",
|
|
|
(int)(sizeof(notify_events) / sizeof(notify_events[0])),
|
|
|
NULL, notify_events);
|
|
|
|
|
|
/* notify-pull-method-supported */
|
|
|
ippAddString(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD | IPP_TAG_COPY,
|
|
|
"notify-pull-method-supported", NULL, "ippget");
|
|
|
|
|
|
/* notify-schemes-supported */
|
|
|
snprintf(filename, sizeof(filename), "%s/notifier", ServerBin);
|
|
|
if ((dir = cupsDirOpen(filename)) != NULL)
|
|
|
{
|
|
|
notifiers = cupsArrayNew((cups_array_func_t)strcmp, NULL);
|
|
|
|
|
|
while ((dent = cupsDirRead(dir)) != NULL)
|
|
|
if (S_ISREG(dent->fileinfo.st_mode) &&
|
|
|
(dent->fileinfo.st_mode & S_IXOTH) != 0)
|
|
|
cupsArrayAdd(notifiers, _cupsStrAlloc(dent->filename));
|
|
|
|
|
|
if (cupsArrayCount(notifiers) > 0)
|
|
|
{
|
|
|
attr = ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"notify-schemes-supported",
|
|
|
cupsArrayCount(notifiers), NULL, NULL);
|
|
|
|
|
|
for (i = 0, notifier = (char *)cupsArrayFirst(notifiers);
|
|
|
notifier;
|
|
|
i ++, notifier = (char *)cupsArrayNext(notifiers))
|
|
|
attr->values[i].string.text = notifier;
|
|
|
}
|
|
|
|
|
|
cupsArrayDelete(notifiers);
|
|
|
cupsDirClose(dir);
|
|
|
}
|
|
|
|
|
|
/* number-up-supported */
|
|
|
ippAddIntegers(CommonData, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
|
|
|
"number-up-supported", sizeof(number_up) / sizeof(number_up[0]), number_up);
|
|
|
|
|
|
/* number-up-layout-supported */
|
|
|
ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_CONST_TAG(IPP_TAG_KEYWORD), "number-up-layout-supported", sizeof(number_up_layout) / sizeof(number_up_layout[0]), NULL, number_up_layout);
|
|
|
|
|
|
/* operations-supported */
|
|
|
ippAddIntegers(CommonData, IPP_TAG_PRINTER, IPP_TAG_ENUM,
|
|
|
"operations-supported", sizeof(ops) / sizeof(ops[0]), ops);
|
|
|
|
|
|
/* orientation-requested-supported */
|
|
|
ippAddIntegers(CommonData, IPP_TAG_PRINTER, IPP_TAG_ENUM,
|
|
|
"orientation-requested-supported", 4, orients);
|
|
|
|
|
|
/* page-delivery-supported */
|
|
|
ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_CONST_TAG(IPP_TAG_KEYWORD), "page-delivery-supported", sizeof(page_delivery) / sizeof(page_delivery[0]), NULL, page_delivery);
|
|
|
|
|
|
/* page-ranges-supported */
|
|
|
ippAddBoolean(CommonData, IPP_TAG_PRINTER, "page-ranges-supported", 1);
|
|
|
|
|
|
/* pdf-k-octets-supported */
|
|
|
ippAddRange(CommonData, IPP_TAG_PRINTER, "pdf-k-octets-supported", 0,
|
|
|
k_supported);
|
|
|
|
|
|
/* pdf-versions-supported */
|
|
|
ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD | IPP_TAG_COPY,
|
|
|
"pdf-versions-supported",
|
|
|
sizeof(pdf_versions) / sizeof(pdf_versions[0]), NULL,
|
|
|
pdf_versions);
|
|
|
|
|
|
/* pdl-override-supported */
|
|
|
ippAddString(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD | IPP_TAG_COPY,
|
|
|
"pdl-override-supported", NULL, "attempted");
|
|
|
|
|
|
/* print-scaling-supported */
|
|
|
ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_CONST_TAG(IPP_TAG_KEYWORD), "print-scaling-supported", sizeof(print_scaling) / sizeof(print_scaling[0]), NULL, print_scaling);
|
|
|
|
|
|
/* printer-get-attributes-supported */
|
|
|
ippAddString(CommonData, IPP_TAG_PRINTER, IPP_CONST_TAG(IPP_TAG_KEYWORD), "printer-get-attributes-supported", NULL, "document-format");
|
|
|
|
|
|
/* printer-op-policy-supported */
|
|
|
attr = ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_NAME | IPP_TAG_COPY,
|
|
|
"printer-op-policy-supported", cupsArrayCount(Policies),
|
|
|
NULL, NULL);
|
|
|
for (i = 0, p = (cupsd_policy_t *)cupsArrayFirst(Policies);
|
|
|
p;
|
|
|
i ++, p = (cupsd_policy_t *)cupsArrayNext(Policies))
|
|
|
attr->values[i].string.text = p->name;
|
|
|
|
|
|
/* printer-settable-attributes-supported */
|
|
|
ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD | IPP_TAG_COPY,
|
|
|
"printer-settable-attributes-supported",
|
|
|
sizeof(printer_settable) / sizeof(printer_settable[0]),
|
|
|
NULL, printer_settable);
|
|
|
|
|
|
/* server-is-sharing-printers */
|
|
|
ippAddBoolean(CommonData, IPP_TAG_PRINTER, "server-is-sharing-printers",
|
|
|
BrowseLocalProtocols != 0 && Browsing);
|
|
|
|
|
|
/* which-jobs-supported */
|
|
|
ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD | IPP_TAG_COPY,
|
|
|
"which-jobs-supported",
|
|
|
sizeof(which_jobs) / sizeof(which_jobs[0]), NULL, which_jobs);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdDeleteAllPrinters()' - Delete all printers from the system.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdDeleteAllPrinters(void)
|
|
|
{
|
|
|
cupsd_printer_t *p; /* Pointer to current printer/class */
|
|
|
|
|
|
|
|
|
for (p = (cupsd_printer_t *)cupsArrayFirst(Printers);
|
|
|
p;
|
|
|
p = (cupsd_printer_t *)cupsArrayNext(Printers))
|
|
|
{
|
|
|
p->op_policy_ptr = DefaultPolicyPtr;
|
|
|
cupsdDeletePrinter(p, 0);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdDeletePrinter()' - Delete a printer from the system.
|
|
|
*/
|
|
|
|
|
|
int /* O - 1 if classes affected, 0 otherwise */
|
|
|
cupsdDeletePrinter(
|
|
|
cupsd_printer_t *p, /* I - Printer to delete */
|
|
|
int update) /* I - Update printers.conf? */
|
|
|
{
|
|
|
int i, /* Looping var */
|
|
|
changed = 0; /* Class changed? */
|
|
|
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdDeletePrinter(p=%p(%s), update=%d)",
|
|
|
p, p->name, update);
|
|
|
|
|
|
/*
|
|
|
* Save the current position in the Printers array...
|
|
|
*/
|
|
|
|
|
|
cupsArraySave(Printers);
|
|
|
|
|
|
/*
|
|
|
* Stop printing on this printer...
|
|
|
*/
|
|
|
|
|
|
cupsdSetPrinterState(p, IPP_PRINTER_STOPPED, update);
|
|
|
|
|
|
p->state = IPP_PRINTER_STOPPED; /* Force for browsed printers */
|
|
|
|
|
|
if (p->job)
|
|
|
cupsdSetJobState(p->job, IPP_JOB_PENDING, CUPSD_JOB_FORCE,
|
|
|
update ? "Job stopped due to printer being deleted." :
|
|
|
"Job stopped.");
|
|
|
|
|
|
/*
|
|
|
* Remove the printer from the list...
|
|
|
*/
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2,
|
|
|
"cupsdDeletePrinter: Removing %s from Printers", p->name);
|
|
|
cupsArrayRemove(Printers, p);
|
|
|
|
|
|
/*
|
|
|
* If p is the default printer, assign a different one...
|
|
|
*/
|
|
|
|
|
|
if (p == DefaultPrinter)
|
|
|
DefaultPrinter = NULL;
|
|
|
|
|
|
/*
|
|
|
* Remove this printer from any classes...
|
|
|
*/
|
|
|
|
|
|
changed = cupsdDeletePrinterFromClasses(p);
|
|
|
|
|
|
/*
|
|
|
* Deregister from any browse protocols...
|
|
|
*/
|
|
|
|
|
|
cupsdDeregisterPrinter(p, 1);
|
|
|
|
|
|
/*
|
|
|
* Remove support files if this is a temporary queue and deregister color
|
|
|
* profiles...
|
|
|
*/
|
|
|
|
|
|
if (p->temporary)
|
|
|
{
|
|
|
char filename[1024]; /* Script/PPD filename */
|
|
|
|
|
|
/*
|
|
|
* Remove any old PPD or script files...
|
|
|
*/
|
|
|
|
|
|
snprintf(filename, sizeof(filename), "%s/ppd/%s.ppd", ServerRoot, p->name);
|
|
|
unlink(filename);
|
|
|
snprintf(filename, sizeof(filename), "%s/ppd/%s.ppd.O", ServerRoot, p->name);
|
|
|
unlink(filename);
|
|
|
|
|
|
snprintf(filename, sizeof(filename), "%s/%s.png", CacheDir, p->name);
|
|
|
unlink(filename);
|
|
|
|
|
|
snprintf(filename, sizeof(filename), "%s/%s.data", CacheDir, p->name);
|
|
|
unlink(filename);
|
|
|
|
|
|
/*
|
|
|
* Unregister color profiles...
|
|
|
*/
|
|
|
|
|
|
cupsdUnregisterColor(p);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Free all memory used by the printer...
|
|
|
*/
|
|
|
|
|
|
if (p->printers != NULL)
|
|
|
free(p->printers);
|
|
|
|
|
|
delete_printer_filters(p);
|
|
|
|
|
|
for (i = 0; i < p->num_reasons; i ++)
|
|
|
_cupsStrFree(p->reasons[i]);
|
|
|
|
|
|
ippDelete(p->attrs);
|
|
|
ippDelete(p->ppd_attrs);
|
|
|
|
|
|
mimeDeleteType(MimeDatabase, p->filetype);
|
|
|
mimeDeleteType(MimeDatabase, p->prefiltertype);
|
|
|
|
|
|
cupsdFreeStrings(&(p->users));
|
|
|
cupsdFreeQuotas(p);
|
|
|
|
|
|
cupsdClearString(&p->uri);
|
|
|
cupsdClearString(&p->hostname);
|
|
|
cupsdClearString(&p->name);
|
|
|
cupsdClearString(&p->location);
|
|
|
cupsdClearString(&p->geo_location);
|
|
|
cupsdClearString(&p->make_model);
|
|
|
cupsdClearString(&p->info);
|
|
|
cupsdClearString(&p->job_sheets[0]);
|
|
|
cupsdClearString(&p->job_sheets[1]);
|
|
|
cupsdClearString(&p->device_uri);
|
|
|
cupsdClearString(&p->sanitized_device_uri);
|
|
|
cupsdClearString(&p->port_monitor);
|
|
|
cupsdClearString(&p->op_policy);
|
|
|
cupsdClearString(&p->error_policy);
|
|
|
cupsdClearString(&p->strings);
|
|
|
|
|
|
cupsdClearString(&p->alert);
|
|
|
cupsdClearString(&p->alert_description);
|
|
|
|
|
|
#if defined(HAVE_DNSSD) || defined(HAVE_AVAHI)
|
|
|
cupsdClearString(&p->pdl);
|
|
|
cupsdClearString(&p->reg_name);
|
|
|
#endif /* HAVE_DNSSD || HAVE_AVAHI */
|
|
|
|
|
|
cupsArrayDelete(p->filetypes);
|
|
|
|
|
|
cupsFreeOptions(p->num_options, p->options);
|
|
|
|
|
|
free(p);
|
|
|
|
|
|
/*
|
|
|
* Restore the previous position in the Printers array...
|
|
|
*/
|
|
|
|
|
|
cupsArrayRestore(Printers);
|
|
|
|
|
|
return (changed);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdDeleteTemporaryPrinters()' - Delete unneeded temporary printers.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdDeleteTemporaryPrinters(int force) /* I - Force deletion instead of auto? */
|
|
|
{
|
|
|
cupsd_printer_t *p; /* Current printer */
|
|
|
time_t unused_time; /* Last time for printer state change */
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Allow temporary printers to stick around for 60 seconds after the last job
|
|
|
* completes.
|
|
|
*/
|
|
|
|
|
|
unused_time = time(NULL) - 60;
|
|
|
|
|
|
for (p = (cupsd_printer_t *)cupsArrayFirst(Printers); p; p = (cupsd_printer_t *)cupsArrayNext(Printers))
|
|
|
{
|
|
|
if (p->temporary && (force || p->state_time < unused_time))
|
|
|
cupsdDeletePrinter(p, 0);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdFindDest()' - Find a destination in the list.
|
|
|
*/
|
|
|
|
|
|
cupsd_printer_t * /* O - Destination in list */
|
|
|
cupsdFindDest(const char *name) /* I - Name of printer or class to find */
|
|
|
{
|
|
|
cupsd_printer_t key; /* Search key */
|
|
|
|
|
|
|
|
|
key.name = (char *)name;
|
|
|
return ((cupsd_printer_t *)cupsArrayFind(Printers, &key));
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdFindPrinter()' - Find a printer in the list.
|
|
|
*/
|
|
|
|
|
|
cupsd_printer_t * /* O - Printer in list */
|
|
|
cupsdFindPrinter(const char *name) /* I - Name of printer to find */
|
|
|
{
|
|
|
cupsd_printer_t *p; /* Printer in list */
|
|
|
|
|
|
|
|
|
if ((p = cupsdFindDest(name)) != NULL && (p->type & CUPS_PRINTER_CLASS))
|
|
|
return (NULL);
|
|
|
else
|
|
|
return (p);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdLoadAllPrinters()' - Load printers from the printers.conf file.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdLoadAllPrinters(void)
|
|
|
{
|
|
|
int i; /* Looping var */
|
|
|
cups_file_t *fp; /* printers.conf file */
|
|
|
int linenum; /* Current line number */
|
|
|
char line[4096], /* Line from file */
|
|
|
*value, /* Pointer to value */
|
|
|
*valueptr; /* Pointer into value */
|
|
|
cupsd_printer_t *p; /* Current printer */
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Open the printers.conf file...
|
|
|
*/
|
|
|
|
|
|
snprintf(line, sizeof(line), "%s/printers.conf", ServerRoot);
|
|
|
if ((fp = cupsdOpenConfFile(line)) == NULL)
|
|
|
return;
|
|
|
|
|
|
/*
|
|
|
* Read printer configurations until we hit EOF...
|
|
|
*/
|
|
|
|
|
|
linenum = 0;
|
|
|
p = NULL;
|
|
|
|
|
|
while (cupsFileGetConf(fp, line, sizeof(line), &value, &linenum))
|
|
|
{
|
|
|
/*
|
|
|
* Decode the directive...
|
|
|
*/
|
|
|
|
|
|
if (!_cups_strcasecmp(line, "NextPrinterId"))
|
|
|
{
|
|
|
if (value && (i = atoi(value)) > 0)
|
|
|
NextPrinterId = i;
|
|
|
else
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR, "Syntax error on line %d of printers.conf.", linenum);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "<Printer") || !_cups_strcasecmp(line, "<DefaultPrinter"))
|
|
|
{
|
|
|
/*
|
|
|
* <Printer name> or <DefaultPrinter name>
|
|
|
*/
|
|
|
|
|
|
if (p == NULL && value)
|
|
|
{
|
|
|
/*
|
|
|
* Add the printer and a base file type...
|
|
|
*/
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG, "Loading printer %s...", value);
|
|
|
|
|
|
p = cupsdAddPrinter(value);
|
|
|
p->accepting = 1;
|
|
|
p->state = IPP_PRINTER_IDLE;
|
|
|
|
|
|
/*
|
|
|
* Set the default printer as needed...
|
|
|
*/
|
|
|
|
|
|
if (!_cups_strcasecmp(line, "<DefaultPrinter"))
|
|
|
DefaultPrinter = p;
|
|
|
}
|
|
|
else
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR,
|
|
|
"Syntax error on line %d of printers.conf.", linenum);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "</Printer>") || !_cups_strcasecmp(line, "</DefaultPrinter>"))
|
|
|
{
|
|
|
if (p != NULL)
|
|
|
{
|
|
|
/*
|
|
|
* Close out the current printer...
|
|
|
*/
|
|
|
|
|
|
if (!p->printer_id)
|
|
|
{
|
|
|
p->printer_id = NextPrinterId ++;
|
|
|
cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
|
|
|
}
|
|
|
|
|
|
cupsdSetPrinterAttrs(p);
|
|
|
|
|
|
if (strncmp(p->device_uri, "file:", 5) && p->state != IPP_PRINTER_STOPPED)
|
|
|
{
|
|
|
/*
|
|
|
* See if the backend exists...
|
|
|
*/
|
|
|
|
|
|
snprintf(line, sizeof(line), "%s/backend/%s", ServerBin, p->device_uri);
|
|
|
|
|
|
if ((valueptr = strchr(line + strlen(ServerBin), ':')) != NULL)
|
|
|
*valueptr = '\0'; /* Chop everything but URI scheme */
|
|
|
|
|
|
if (access(line, 0))
|
|
|
{
|
|
|
/*
|
|
|
* Backend does not exist, stop printer...
|
|
|
*/
|
|
|
|
|
|
p->state = IPP_PRINTER_STOPPED;
|
|
|
snprintf(p->state_message, sizeof(p->state_message), "Backend %s does not exist!", line);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
p = NULL;
|
|
|
}
|
|
|
else
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR,
|
|
|
"Syntax error on line %d of printers.conf.", linenum);
|
|
|
}
|
|
|
else if (!p)
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR,
|
|
|
"Syntax error on line %d of printers.conf.", linenum);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "PrinterId"))
|
|
|
{
|
|
|
if (value && (i = atoi(value)) > 0)
|
|
|
p->printer_id = i;
|
|
|
else
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR, "Bad PrinterId on line %d of printers.conf.", linenum);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "UUID"))
|
|
|
{
|
|
|
if (value && !strncmp(value, "urn:uuid:", 9))
|
|
|
cupsdSetString(&(p->uuid), value);
|
|
|
else
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR,
|
|
|
"Bad UUID on line %d of printers.conf.", linenum);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "AuthInfoRequired"))
|
|
|
{
|
|
|
if (!cupsdSetAuthInfoRequired(p, value, NULL))
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR,
|
|
|
"Bad AuthInfoRequired on line %d of printers.conf.",
|
|
|
linenum);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "Info"))
|
|
|
{
|
|
|
cupsdSetString(&p->info, value ? value : "");
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "MakeModel"))
|
|
|
{
|
|
|
if (value)
|
|
|
cupsdSetString(&p->make_model, value);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "Location"))
|
|
|
{
|
|
|
cupsdSetString(&p->location, value ? value : "");
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "GeoLocation"))
|
|
|
{
|
|
|
cupsdSetString(&p->geo_location, value ? value : "");
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "Organization"))
|
|
|
{
|
|
|
cupsdSetString(&p->organization, value ? value : "");
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "OrganizationalUnit"))
|
|
|
{
|
|
|
cupsdSetString(&p->organizational_unit, value ? value : "");
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "DeviceURI"))
|
|
|
{
|
|
|
if (value)
|
|
|
cupsdSetDeviceURI(p, value);
|
|
|
else
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR,
|
|
|
"Syntax error on line %d of printers.conf.", linenum);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "Option") && value)
|
|
|
{
|
|
|
/*
|
|
|
* Option name value
|
|
|
*/
|
|
|
|
|
|
for (valueptr = value; *valueptr && !isspace(*valueptr & 255); valueptr ++);
|
|
|
|
|
|
if (!*valueptr)
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR,
|
|
|
"Syntax error on line %d of printers.conf.", linenum);
|
|
|
else
|
|
|
{
|
|
|
for (; *valueptr && isspace(*valueptr & 255); *valueptr++ = '\0');
|
|
|
|
|
|
p->num_options = cupsAddOption(value, valueptr, p->num_options,
|
|
|
&(p->options));
|
|
|
}
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "PortMonitor"))
|
|
|
{
|
|
|
if (value && strcmp(value, "none"))
|
|
|
cupsdSetString(&p->port_monitor, value);
|
|
|
else if (value)
|
|
|
cupsdClearString(&p->port_monitor);
|
|
|
else
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR,
|
|
|
"Syntax error on line %d of printers.conf.", linenum);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "Reason"))
|
|
|
{
|
|
|
if (value &&
|
|
|
strcmp(value, "connecting-to-device") &&
|
|
|
strcmp(value, "cups-insecure-filter-warning") &&
|
|
|
strcmp(value, "cups-missing-filter-warning"))
|
|
|
{
|
|
|
for (i = 0 ; i < p->num_reasons; i ++)
|
|
|
if (!strcmp(value, p->reasons[i]))
|
|
|
break;
|
|
|
|
|
|
if (i >= p->num_reasons &&
|
|
|
p->num_reasons < (int)(sizeof(p->reasons) / sizeof(p->reasons[0])))
|
|
|
{
|
|
|
p->reasons[p->num_reasons] = _cupsStrAlloc(value);
|
|
|
p->num_reasons ++;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR,
|
|
|
"Syntax error on line %d of printers.conf.", linenum);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "State"))
|
|
|
{
|
|
|
/*
|
|
|
* Set the initial queue state...
|
|
|
*/
|
|
|
|
|
|
if (value && !_cups_strcasecmp(value, "idle"))
|
|
|
p->state = IPP_PRINTER_IDLE;
|
|
|
else if (value && !_cups_strcasecmp(value, "stopped"))
|
|
|
{
|
|
|
p->state = IPP_PRINTER_STOPPED;
|
|
|
|
|
|
for (i = 0 ; i < p->num_reasons; i ++)
|
|
|
if (!strcmp("paused", p->reasons[i]))
|
|
|
break;
|
|
|
|
|
|
if (i >= p->num_reasons &&
|
|
|
p->num_reasons < (int)(sizeof(p->reasons) / sizeof(p->reasons[0])))
|
|
|
{
|
|
|
p->reasons[p->num_reasons] = _cupsStrAlloc("paused");
|
|
|
p->num_reasons ++;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR,
|
|
|
"Syntax error on line %d of printers.conf.", linenum);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "StateMessage"))
|
|
|
{
|
|
|
/*
|
|
|
* Set the initial queue state message...
|
|
|
*/
|
|
|
|
|
|
if (value)
|
|
|
strlcpy(p->state_message, value, sizeof(p->state_message));
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "StateTime"))
|
|
|
{
|
|
|
/*
|
|
|
* Set the state time...
|
|
|
*/
|
|
|
|
|
|
if (value)
|
|
|
p->state_time = atoi(value);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "ConfigTime"))
|
|
|
{
|
|
|
/*
|
|
|
* Set the config time...
|
|
|
*/
|
|
|
|
|
|
if (value)
|
|
|
p->config_time = atoi(value);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "Accepting"))
|
|
|
{
|
|
|
/*
|
|
|
* Set the initial accepting state...
|
|
|
*/
|
|
|
|
|
|
if (value &&
|
|
|
(!_cups_strcasecmp(value, "yes") ||
|
|
|
!_cups_strcasecmp(value, "on") ||
|
|
|
!_cups_strcasecmp(value, "true")))
|
|
|
p->accepting = 1;
|
|
|
else if (value &&
|
|
|
(!_cups_strcasecmp(value, "no") ||
|
|
|
!_cups_strcasecmp(value, "off") ||
|
|
|
!_cups_strcasecmp(value, "false")))
|
|
|
p->accepting = 0;
|
|
|
else
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR,
|
|
|
"Syntax error on line %d of printers.conf.", linenum);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "Type"))
|
|
|
{
|
|
|
if (value)
|
|
|
p->type = (cups_ptype_t)atoi(value);
|
|
|
else
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR,
|
|
|
"Syntax error on line %d of printers.conf.", linenum);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "Shared"))
|
|
|
{
|
|
|
/*
|
|
|
* Set the initial shared state...
|
|
|
*/
|
|
|
|
|
|
if (value &&
|
|
|
(!_cups_strcasecmp(value, "yes") ||
|
|
|
!_cups_strcasecmp(value, "on") ||
|
|
|
!_cups_strcasecmp(value, "true")))
|
|
|
p->shared = 1;
|
|
|
else if (value &&
|
|
|
(!_cups_strcasecmp(value, "no") ||
|
|
|
!_cups_strcasecmp(value, "off") ||
|
|
|
!_cups_strcasecmp(value, "false")))
|
|
|
p->shared = 0;
|
|
|
else
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR,
|
|
|
"Syntax error on line %d of printers.conf.", linenum);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "JobSheets"))
|
|
|
{
|
|
|
/*
|
|
|
* Set the initial job sheets...
|
|
|
*/
|
|
|
|
|
|
if (value)
|
|
|
{
|
|
|
for (valueptr = value; *valueptr && !isspace(*valueptr & 255); valueptr ++);
|
|
|
|
|
|
if (*valueptr)
|
|
|
*valueptr++ = '\0';
|
|
|
|
|
|
cupsdSetString(&p->job_sheets[0], value);
|
|
|
|
|
|
while (isspace(*valueptr & 255))
|
|
|
valueptr ++;
|
|
|
|
|
|
if (*valueptr)
|
|
|
{
|
|
|
for (value = valueptr; *valueptr && !isspace(*valueptr & 255); valueptr ++);
|
|
|
|
|
|
if (*valueptr)
|
|
|
*valueptr = '\0';
|
|
|
|
|
|
cupsdSetString(&p->job_sheets[1], value);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR,
|
|
|
"Syntax error on line %d of printers.conf.", linenum);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "AllowUser"))
|
|
|
{
|
|
|
if (value)
|
|
|
{
|
|
|
p->deny_users = 0;
|
|
|
cupsdAddString(&(p->users), value);
|
|
|
}
|
|
|
else
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR,
|
|
|
"Syntax error on line %d of printers.conf.", linenum);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "DenyUser"))
|
|
|
{
|
|
|
if (value)
|
|
|
{
|
|
|
p->deny_users = 1;
|
|
|
cupsdAddString(&(p->users), value);
|
|
|
}
|
|
|
else
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR,
|
|
|
"Syntax error on line %d of printers.conf.", linenum);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "QuotaPeriod"))
|
|
|
{
|
|
|
if (value)
|
|
|
p->quota_period = atoi(value);
|
|
|
else
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR,
|
|
|
"Syntax error on line %d of printers.conf.", linenum);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "PageLimit"))
|
|
|
{
|
|
|
if (value)
|
|
|
p->page_limit = atoi(value);
|
|
|
else
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR,
|
|
|
"Syntax error on line %d of printers.conf.", linenum);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "KLimit"))
|
|
|
{
|
|
|
if (value)
|
|
|
p->k_limit = atoi(value);
|
|
|
else
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR,
|
|
|
"Syntax error on line %d of printers.conf.", linenum);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "OpPolicy"))
|
|
|
{
|
|
|
if (value)
|
|
|
{
|
|
|
cupsd_policy_t *pol; /* Policy */
|
|
|
|
|
|
|
|
|
if ((pol = cupsdFindPolicy(value)) != NULL)
|
|
|
{
|
|
|
cupsdSetString(&p->op_policy, value);
|
|
|
p->op_policy_ptr = pol;
|
|
|
}
|
|
|
else
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR,
|
|
|
"Bad policy \"%s\" on line %d of printers.conf",
|
|
|
value, linenum);
|
|
|
}
|
|
|
else
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR,
|
|
|
"Syntax error on line %d of printers.conf.", linenum);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "ErrorPolicy"))
|
|
|
{
|
|
|
if (value)
|
|
|
{
|
|
|
if (strcmp(value, "retry-current-job") &&
|
|
|
strcmp(value, "abort-job") &&
|
|
|
strcmp(value, "retry-job") &&
|
|
|
strcmp(value, "stop-printer"))
|
|
|
cupsdLogMessage(CUPSD_LOG_ALERT, "Invalid ErrorPolicy \"%s\" on line %d or printers.conf.", ErrorPolicy, linenum);
|
|
|
else
|
|
|
cupsdSetString(&p->error_policy, value);
|
|
|
}
|
|
|
else
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR, "Syntax error on line %d of printers.conf.", linenum);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "Attribute") && value)
|
|
|
{
|
|
|
for (valueptr = value; *valueptr && !isspace(*valueptr & 255); valueptr ++);
|
|
|
|
|
|
if (!*valueptr)
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR,
|
|
|
"Syntax error on line %d of printers.conf.", linenum);
|
|
|
else
|
|
|
{
|
|
|
for (; *valueptr && isspace(*valueptr & 255); *valueptr++ = '\0');
|
|
|
|
|
|
if (!p->attrs)
|
|
|
cupsdSetPrinterAttrs(p);
|
|
|
|
|
|
if (!strcmp(value, "marker-change-time"))
|
|
|
p->marker_time = atoi(valueptr);
|
|
|
else
|
|
|
cupsdSetPrinterAttr(p, value, valueptr);
|
|
|
}
|
|
|
}
|
|
|
else if (_cups_strcasecmp(line, "Filter") &&
|
|
|
_cups_strcasecmp(line, "Prefilter") &&
|
|
|
_cups_strcasecmp(line, "Product"))
|
|
|
{
|
|
|
/*
|
|
|
* Something else we don't understand (and that wasn't used in a prior
|
|
|
* release of CUPS...
|
|
|
*/
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR,
|
|
|
"Unknown configuration directive %s on line %d of "
|
|
|
"printers.conf.", line, linenum);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
cupsFileClose(fp);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdRenamePrinter()' - Rename a printer.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdRenamePrinter(
|
|
|
cupsd_printer_t *p, /* I - Printer */
|
|
|
const char *name) /* I - New name */
|
|
|
{
|
|
|
/*
|
|
|
* Remove the printer from the array(s) first...
|
|
|
*/
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2,
|
|
|
"cupsdRenamePrinter: Removing %s from Printers", p->name);
|
|
|
cupsArrayRemove(Printers, p);
|
|
|
|
|
|
/*
|
|
|
* Rename the printer type...
|
|
|
*/
|
|
|
|
|
|
mimeDeleteType(MimeDatabase, p->filetype);
|
|
|
p->filetype = mimeAddType(MimeDatabase, "printer", name);
|
|
|
|
|
|
if (p->prefiltertype)
|
|
|
{
|
|
|
mimeDeleteType(MimeDatabase, p->prefiltertype);
|
|
|
p->prefiltertype = mimeAddType(MimeDatabase, "prefilter", name);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Rename the printer...
|
|
|
*/
|
|
|
|
|
|
cupsdSetString(&p->name, name);
|
|
|
|
|
|
/*
|
|
|
* Reset printer attributes...
|
|
|
*/
|
|
|
|
|
|
cupsdSetPrinterAttrs(p);
|
|
|
|
|
|
/*
|
|
|
* Add the printer back to the printer array(s)...
|
|
|
*/
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2,
|
|
|
"cupsdRenamePrinter: Adding %s to Printers", p->name);
|
|
|
cupsArrayAdd(Printers, p);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdSaveAllPrinters()' - Save all printer definitions to the printers.conf
|
|
|
* file.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdSaveAllPrinters(void)
|
|
|
{
|
|
|
int i; /* Looping var */
|
|
|
cups_file_t *fp; /* printers.conf file */
|
|
|
char filename[1024], /* printers.conf filename */
|
|
|
temp[1024], /* Temporary string */
|
|
|
value[2048], /* Value string */
|
|
|
*ptr, /* Pointer into value */
|
|
|
*name; /* Current user/group name */
|
|
|
cupsd_printer_t *printer; /* Current printer class */
|
|
|
time_t curtime; /* Current time */
|
|
|
struct tm curdate; /* Current date */
|
|
|
cups_option_t *option; /* Current option */
|
|
|
ipp_attribute_t *marker; /* Current marker attribute */
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Create the printers.conf file...
|
|
|
*/
|
|
|
|
|
|
snprintf(filename, sizeof(filename), "%s/printers.conf", ServerRoot);
|
|
|
|
|
|
if ((fp = cupsdCreateConfFile(filename, ConfigFilePerm & 0600)) == NULL)
|
|
|
return;
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_INFO, "Saving printers.conf...");
|
|
|
|
|
|
/*
|
|
|
* Write a small header to the file...
|
|
|
*/
|
|
|
|
|
|
time(&curtime);
|
|
|
localtime_r(&curtime, &curdate);
|
|
|
strftime(temp, sizeof(temp) - 1, "%Y-%m-%d %H:%M", &curdate);
|
|
|
|
|
|
cupsFilePuts(fp, "# Printer configuration file for " CUPS_SVERSION "\n");
|
|
|
cupsFilePrintf(fp, "# Written by cupsd on %s\n", temp);
|
|
|
cupsFilePuts(fp, "# DO NOT EDIT THIS FILE WHEN CUPSD IS RUNNING\n");
|
|
|
|
|
|
cupsFilePrintf(fp, "NextPrinterId %d\n", NextPrinterId);
|
|
|
|
|
|
/*
|
|
|
* Write each local printer known to the system...
|
|
|
*/
|
|
|
|
|
|
for (printer = (cupsd_printer_t *)cupsArrayFirst(Printers);
|
|
|
printer;
|
|
|
printer = (cupsd_printer_t *)cupsArrayNext(Printers))
|
|
|
{
|
|
|
/*
|
|
|
* Skip printer classes and temporary queues...
|
|
|
*/
|
|
|
|
|
|
if ((printer->type & CUPS_PRINTER_CLASS) || printer->temporary)
|
|
|
continue;
|
|
|
|
|
|
/*
|
|
|
* Write printers as needed...
|
|
|
*/
|
|
|
|
|
|
if (printer == DefaultPrinter)
|
|
|
cupsFilePrintf(fp, "<DefaultPrinter %s>\n", printer->name);
|
|
|
else
|
|
|
cupsFilePrintf(fp, "<Printer %s>\n", printer->name);
|
|
|
|
|
|
if (printer->printer_id)
|
|
|
cupsFilePrintf(fp, "PrinterId %d\n", printer->printer_id);
|
|
|
|
|
|
cupsFilePrintf(fp, "UUID %s\n", printer->uuid);
|
|
|
|
|
|
if (printer->num_auth_info_required > 0)
|
|
|
{
|
|
|
switch (printer->num_auth_info_required)
|
|
|
{
|
|
|
case 1 :
|
|
|
strlcpy(value, printer->auth_info_required[0], sizeof(value));
|
|
|
break;
|
|
|
|
|
|
case 2 :
|
|
|
snprintf(value, sizeof(value), "%s,%s",
|
|
|
printer->auth_info_required[0],
|
|
|
printer->auth_info_required[1]);
|
|
|
break;
|
|
|
|
|
|
case 3 :
|
|
|
default :
|
|
|
snprintf(value, sizeof(value), "%s,%s,%s",
|
|
|
printer->auth_info_required[0],
|
|
|
printer->auth_info_required[1],
|
|
|
printer->auth_info_required[2]);
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
cupsFilePutConf(fp, "AuthInfoRequired", value);
|
|
|
}
|
|
|
|
|
|
if (printer->info)
|
|
|
cupsFilePutConf(fp, "Info", printer->info);
|
|
|
|
|
|
if (printer->location)
|
|
|
cupsFilePutConf(fp, "Location", printer->location);
|
|
|
|
|
|
if (printer->geo_location)
|
|
|
cupsFilePutConf(fp, "GeoLocation", printer->geo_location);
|
|
|
|
|
|
if (printer->make_model)
|
|
|
cupsFilePutConf(fp, "MakeModel", printer->make_model);
|
|
|
|
|
|
if (printer->organization)
|
|
|
cupsFilePutConf(fp, "Organization", printer->organization);
|
|
|
|
|
|
if (printer->organizational_unit)
|
|
|
cupsFilePutConf(fp, "OrganizationalUnit", printer->organizational_unit);
|
|
|
|
|
|
cupsFilePutConf(fp, "DeviceURI", printer->device_uri);
|
|
|
|
|
|
if (printer->port_monitor)
|
|
|
cupsFilePutConf(fp, "PortMonitor", printer->port_monitor);
|
|
|
|
|
|
if (printer->state == IPP_PRINTER_STOPPED)
|
|
|
{
|
|
|
cupsFilePuts(fp, "State Stopped\n");
|
|
|
|
|
|
if (printer->state_message[0])
|
|
|
cupsFilePutConf(fp, "StateMessage", printer->state_message);
|
|
|
}
|
|
|
else
|
|
|
cupsFilePuts(fp, "State Idle\n");
|
|
|
|
|
|
cupsFilePrintf(fp, "StateTime %d\n", (int)printer->state_time);
|
|
|
cupsFilePrintf(fp, "ConfigTime %d\n", (int)printer->config_time);
|
|
|
|
|
|
for (i = 0; i < printer->num_reasons; i ++)
|
|
|
if (strcmp(printer->reasons[i], "connecting-to-device") &&
|
|
|
strcmp(printer->reasons[i], "cups-insecure-filter-warning") &&
|
|
|
strcmp(printer->reasons[i], "cups-missing-filter-warning"))
|
|
|
cupsFilePutConf(fp, "Reason", printer->reasons[i]);
|
|
|
|
|
|
cupsFilePrintf(fp, "Type %d\n", printer->type);
|
|
|
|
|
|
if (printer->accepting)
|
|
|
cupsFilePuts(fp, "Accepting Yes\n");
|
|
|
else
|
|
|
cupsFilePuts(fp, "Accepting No\n");
|
|
|
|
|
|
if (printer->shared)
|
|
|
cupsFilePuts(fp, "Shared Yes\n");
|
|
|
else
|
|
|
cupsFilePuts(fp, "Shared No\n");
|
|
|
|
|
|
snprintf(value, sizeof(value), "%s %s", printer->job_sheets[0],
|
|
|
printer->job_sheets[1]);
|
|
|
cupsFilePutConf(fp, "JobSheets", value);
|
|
|
|
|
|
cupsFilePrintf(fp, "QuotaPeriod %d\n", printer->quota_period);
|
|
|
cupsFilePrintf(fp, "PageLimit %d\n", printer->page_limit);
|
|
|
cupsFilePrintf(fp, "KLimit %d\n", printer->k_limit);
|
|
|
|
|
|
for (name = (char *)cupsArrayFirst(printer->users);
|
|
|
name;
|
|
|
name = (char *)cupsArrayNext(printer->users))
|
|
|
cupsFilePutConf(fp, printer->deny_users ? "DenyUser" : "AllowUser", name);
|
|
|
|
|
|
if (printer->op_policy)
|
|
|
cupsFilePutConf(fp, "OpPolicy", printer->op_policy);
|
|
|
if (printer->error_policy)
|
|
|
cupsFilePutConf(fp, "ErrorPolicy", printer->error_policy);
|
|
|
|
|
|
for (i = printer->num_options, option = printer->options;
|
|
|
i > 0;
|
|
|
i --, option ++)
|
|
|
{
|
|
|
snprintf(value, sizeof(value), "%s %s", option->name, option->value);
|
|
|
cupsFilePutConf(fp, "Option", value);
|
|
|
}
|
|
|
|
|
|
if ((marker = ippFindAttribute(printer->attrs, "marker-colors",
|
|
|
IPP_TAG_NAME)) != NULL)
|
|
|
{
|
|
|
snprintf(value, sizeof(value), "%s ", marker->name);
|
|
|
|
|
|
for (i = 0, ptr = value + strlen(value);
|
|
|
i < marker->num_values && ptr < (value + sizeof(value) - 1);
|
|
|
i ++)
|
|
|
{
|
|
|
if (i)
|
|
|
*ptr++ = ',';
|
|
|
|
|
|
strlcpy(ptr, marker->values[i].string.text, (size_t)(value + sizeof(value) - ptr));
|
|
|
ptr += strlen(ptr);
|
|
|
}
|
|
|
|
|
|
*ptr = '\0';
|
|
|
cupsFilePutConf(fp, "Attribute", value);
|
|
|
}
|
|
|
|
|
|
if ((marker = ippFindAttribute(printer->attrs, "marker-levels",
|
|
|
IPP_TAG_INTEGER)) != NULL)
|
|
|
{
|
|
|
cupsFilePrintf(fp, "Attribute %s %d", marker->name,
|
|
|
marker->values[0].integer);
|
|
|
for (i = 1; i < marker->num_values; i ++)
|
|
|
cupsFilePrintf(fp, ",%d", marker->values[i].integer);
|
|
|
cupsFilePuts(fp, "\n");
|
|
|
}
|
|
|
|
|
|
if ((marker = ippFindAttribute(printer->attrs, "marker-low-levels",
|
|
|
IPP_TAG_INTEGER)) != NULL)
|
|
|
{
|
|
|
cupsFilePrintf(fp, "Attribute %s %d", marker->name,
|
|
|
marker->values[0].integer);
|
|
|
for (i = 1; i < marker->num_values; i ++)
|
|
|
cupsFilePrintf(fp, ",%d", marker->values[i].integer);
|
|
|
cupsFilePuts(fp, "\n");
|
|
|
}
|
|
|
|
|
|
if ((marker = ippFindAttribute(printer->attrs, "marker-high-levels",
|
|
|
IPP_TAG_INTEGER)) != NULL)
|
|
|
{
|
|
|
cupsFilePrintf(fp, "Attribute %s %d", marker->name,
|
|
|
marker->values[0].integer);
|
|
|
for (i = 1; i < marker->num_values; i ++)
|
|
|
cupsFilePrintf(fp, ",%d", marker->values[i].integer);
|
|
|
cupsFilePuts(fp, "\n");
|
|
|
}
|
|
|
|
|
|
if ((marker = ippFindAttribute(printer->attrs, "marker-message",
|
|
|
IPP_TAG_TEXT)) != NULL)
|
|
|
{
|
|
|
snprintf(value, sizeof(value), "%s %s", marker->name,
|
|
|
marker->values[0].string.text);
|
|
|
|
|
|
cupsFilePutConf(fp, "Attribute", value);
|
|
|
}
|
|
|
|
|
|
if ((marker = ippFindAttribute(printer->attrs, "marker-names",
|
|
|
IPP_TAG_NAME)) != NULL)
|
|
|
{
|
|
|
snprintf(value, sizeof(value), "%s ", marker->name);
|
|
|
|
|
|
for (i = 0, ptr = value + strlen(value);
|
|
|
i < marker->num_values && ptr < (value + sizeof(value) - 1);
|
|
|
i ++)
|
|
|
{
|
|
|
if (i)
|
|
|
*ptr++ = ',';
|
|
|
|
|
|
strlcpy(ptr, marker->values[i].string.text, (size_t)(value + sizeof(value) - ptr));
|
|
|
ptr += strlen(ptr);
|
|
|
}
|
|
|
|
|
|
*ptr = '\0';
|
|
|
cupsFilePutConf(fp, "Attribute", value);
|
|
|
}
|
|
|
|
|
|
if ((marker = ippFindAttribute(printer->attrs, "marker-types",
|
|
|
IPP_TAG_KEYWORD)) != NULL)
|
|
|
{
|
|
|
snprintf(value, sizeof(value), "%s ", marker->name);
|
|
|
|
|
|
for (i = 0, ptr = value + strlen(value);
|
|
|
i < marker->num_values && ptr < (value + sizeof(value) - 1);
|
|
|
i ++)
|
|
|
{
|
|
|
if (i)
|
|
|
*ptr++ = ',';
|
|
|
|
|
|
strlcpy(ptr, marker->values[i].string.text, (size_t)(value + sizeof(value) - ptr));
|
|
|
ptr += strlen(ptr);
|
|
|
}
|
|
|
|
|
|
*ptr = '\0';
|
|
|
cupsFilePutConf(fp, "Attribute", value);
|
|
|
}
|
|
|
|
|
|
if (printer->marker_time)
|
|
|
cupsFilePrintf(fp, "Attribute marker-change-time %ld\n",
|
|
|
(long)printer->marker_time);
|
|
|
|
|
|
if (printer == DefaultPrinter)
|
|
|
cupsFilePuts(fp, "</DefaultPrinter>\n");
|
|
|
else
|
|
|
cupsFilePuts(fp, "</Printer>\n");
|
|
|
}
|
|
|
|
|
|
cupsdCloseCreatedConfFile(fp, filename);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdSetAuthInfoRequired()' - Set the required authentication info.
|
|
|
*/
|
|
|
|
|
|
int /* O - 1 if value OK, 0 otherwise */
|
|
|
cupsdSetAuthInfoRequired(
|
|
|
cupsd_printer_t *p, /* I - Printer */
|
|
|
const char *values, /* I - Plain text value (or NULL) */
|
|
|
ipp_attribute_t *attr) /* I - IPP attribute value (or NULL) */
|
|
|
{
|
|
|
int i; /* Looping var */
|
|
|
|
|
|
|
|
|
p->num_auth_info_required = 0;
|
|
|
|
|
|
/*
|
|
|
* Do we have a plain text value?
|
|
|
*/
|
|
|
|
|
|
if (values)
|
|
|
{
|
|
|
/*
|
|
|
* Yes, grab the keywords...
|
|
|
*/
|
|
|
|
|
|
const char *end; /* End of current value */
|
|
|
|
|
|
|
|
|
while (*values && p->num_auth_info_required < 4)
|
|
|
{
|
|
|
if ((end = strchr(values, ',')) == NULL)
|
|
|
end = values + strlen(values);
|
|
|
|
|
|
if ((end - values) == 4 && !strncmp(values, "none", 4))
|
|
|
{
|
|
|
if (p->num_auth_info_required != 0 || *end)
|
|
|
return (0);
|
|
|
|
|
|
p->auth_info_required[p->num_auth_info_required] = "none";
|
|
|
p->num_auth_info_required ++;
|
|
|
|
|
|
return (1);
|
|
|
}
|
|
|
else if ((end - values) == 9 && !strncmp(values, "negotiate", 9))
|
|
|
{
|
|
|
if (p->num_auth_info_required != 0 || *end)
|
|
|
return (0);
|
|
|
|
|
|
p->auth_info_required[p->num_auth_info_required] = "negotiate";
|
|
|
p->num_auth_info_required ++;
|
|
|
|
|
|
/*
|
|
|
* Don't allow sharing of queues that require Kerberos authentication.
|
|
|
*/
|
|
|
|
|
|
if (p->shared)
|
|
|
{
|
|
|
cupsdDeregisterPrinter(p, 1);
|
|
|
p->shared = 0;
|
|
|
}
|
|
|
}
|
|
|
else if ((end - values) == 6 && !strncmp(values, "domain", 6))
|
|
|
{
|
|
|
p->auth_info_required[p->num_auth_info_required] = "domain";
|
|
|
p->num_auth_info_required ++;
|
|
|
}
|
|
|
else if ((end - values) == 8 && !strncmp(values, "password", 8))
|
|
|
{
|
|
|
p->auth_info_required[p->num_auth_info_required] = "password";
|
|
|
p->num_auth_info_required ++;
|
|
|
}
|
|
|
else if ((end - values) == 8 && !strncmp(values, "username", 8))
|
|
|
{
|
|
|
p->auth_info_required[p->num_auth_info_required] = "username";
|
|
|
p->num_auth_info_required ++;
|
|
|
}
|
|
|
else
|
|
|
return (0);
|
|
|
|
|
|
values = (*end) ? end + 1 : end;
|
|
|
}
|
|
|
|
|
|
if (p->num_auth_info_required == 0)
|
|
|
{
|
|
|
p->auth_info_required[0] = "none";
|
|
|
p->num_auth_info_required = 1;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Update the printer-type value as needed...
|
|
|
*/
|
|
|
|
|
|
if (p->num_auth_info_required > 1 ||
|
|
|
strcmp(p->auth_info_required[0], "none"))
|
|
|
p->type |= CUPS_PRINTER_AUTHENTICATED;
|
|
|
else
|
|
|
p->type &= (cups_ptype_t)~CUPS_PRINTER_AUTHENTICATED;
|
|
|
|
|
|
return (1);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Grab values from an attribute instead...
|
|
|
*/
|
|
|
|
|
|
if (!attr || attr->num_values > 4)
|
|
|
return (0);
|
|
|
|
|
|
for (i = 0; i < attr->num_values; i ++)
|
|
|
{
|
|
|
if (!strcmp(attr->values[i].string.text, "none"))
|
|
|
{
|
|
|
if (p->num_auth_info_required != 0 || attr->num_values != 1)
|
|
|
return (0);
|
|
|
|
|
|
p->auth_info_required[p->num_auth_info_required] = "none";
|
|
|
p->num_auth_info_required ++;
|
|
|
|
|
|
return (1);
|
|
|
}
|
|
|
else if (!strcmp(attr->values[i].string.text, "negotiate"))
|
|
|
{
|
|
|
if (p->num_auth_info_required != 0 || attr->num_values != 1)
|
|
|
return (0);
|
|
|
|
|
|
p->auth_info_required[p->num_auth_info_required] = "negotiate";
|
|
|
p->num_auth_info_required ++;
|
|
|
|
|
|
/*
|
|
|
* Don't allow sharing of queues that require Kerberos authentication.
|
|
|
*/
|
|
|
|
|
|
if (p->shared)
|
|
|
{
|
|
|
cupsdDeregisterPrinter(p, 1);
|
|
|
p->shared = 0;
|
|
|
}
|
|
|
|
|
|
return (1);
|
|
|
}
|
|
|
else if (!strcmp(attr->values[i].string.text, "domain"))
|
|
|
{
|
|
|
p->auth_info_required[p->num_auth_info_required] = "domain";
|
|
|
p->num_auth_info_required ++;
|
|
|
}
|
|
|
else if (!strcmp(attr->values[i].string.text, "password"))
|
|
|
{
|
|
|
p->auth_info_required[p->num_auth_info_required] = "password";
|
|
|
p->num_auth_info_required ++;
|
|
|
}
|
|
|
else if (!strcmp(attr->values[i].string.text, "username"))
|
|
|
{
|
|
|
p->auth_info_required[p->num_auth_info_required] = "username";
|
|
|
p->num_auth_info_required ++;
|
|
|
}
|
|
|
else
|
|
|
return (0);
|
|
|
}
|
|
|
|
|
|
return (1);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdSetDeviceURI()' - Set the device URI for a printer.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdSetDeviceURI(cupsd_printer_t *p, /* I - Printer */
|
|
|
const char *uri) /* I - Device URI */
|
|
|
{
|
|
|
char buffer[1024], /* URI buffer */
|
|
|
*start, /* Start of data after scheme */
|
|
|
*slash, /* First slash after scheme:// */
|
|
|
*ptr; /* Pointer into user@host:port part */
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Set the full device URI..
|
|
|
*/
|
|
|
|
|
|
cupsdSetString(&(p->device_uri), uri);
|
|
|
|
|
|
/*
|
|
|
* Copy the device URI to a temporary buffer so we can sanitize any auth
|
|
|
* info in it...
|
|
|
*/
|
|
|
|
|
|
strlcpy(buffer, uri, sizeof(buffer));
|
|
|
|
|
|
/*
|
|
|
* Find the end of the scheme:// part...
|
|
|
*/
|
|
|
|
|
|
if ((ptr = strchr(buffer, ':')) != NULL)
|
|
|
{
|
|
|
for (start = ptr + 1; *start; start ++)
|
|
|
if (*start != '/')
|
|
|
break;
|
|
|
|
|
|
/*
|
|
|
* Find the next slash (/) in the URI...
|
|
|
*/
|
|
|
|
|
|
if ((slash = strchr(start, '/')) == NULL)
|
|
|
slash = start + strlen(start); /* No slash, point to the end */
|
|
|
|
|
|
/*
|
|
|
* Check for an @ sign before the slash...
|
|
|
*/
|
|
|
|
|
|
if ((ptr = strchr(start, '@')) != NULL && ptr < slash)
|
|
|
{
|
|
|
/*
|
|
|
* Found an @ sign and it is before the resource part, so we have
|
|
|
* an authentication string. Copy the remaining URI over the
|
|
|
* authentication string...
|
|
|
*/
|
|
|
|
|
|
_cups_strcpy(start, ptr + 1);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Save the sanitized URI...
|
|
|
*/
|
|
|
|
|
|
cupsdSetString(&(p->sanitized_device_uri), buffer);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdSetPrinterAttr()' - Set a printer attribute.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdSetPrinterAttr(
|
|
|
cupsd_printer_t *p, /* I - Printer */
|
|
|
const char *name, /* I - Attribute name */
|
|
|
const char *value) /* I - Attribute value string */
|
|
|
{
|
|
|
ipp_attribute_t *attr; /* Attribute */
|
|
|
int i, /* Looping var */
|
|
|
count; /* Number of values */
|
|
|
char *temp, /* Temporary copy of value string */
|
|
|
*ptr, /* Pointer into value */
|
|
|
*start, /* Start of value */
|
|
|
quote; /* Quote character */
|
|
|
ipp_tag_t value_tag; /* Value tag for this attribute */
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Don't allow empty values...
|
|
|
*/
|
|
|
|
|
|
if (!*value && strcmp(name, "marker-message"))
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR, "Ignoring empty \"%s\" attribute", name);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Copy the value string so we can do what we want with it...
|
|
|
*/
|
|
|
|
|
|
if ((temp = strdup(value)) == NULL)
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR,
|
|
|
"Unable to duplicate value for \"%s\" attribute.", name);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Count the number of values...
|
|
|
*/
|
|
|
|
|
|
for (count = 1, quote = '\0', ptr = temp;
|
|
|
*ptr;
|
|
|
ptr ++)
|
|
|
{
|
|
|
if (*ptr == quote)
|
|
|
quote = '\0';
|
|
|
else if (quote)
|
|
|
continue;
|
|
|
else if (*ptr == '\\' && ptr[1])
|
|
|
ptr ++;
|
|
|
else if (*ptr == '\'' || *ptr == '\"')
|
|
|
quote = *ptr;
|
|
|
else if (*ptr == ',')
|
|
|
count ++;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Then add or update the attribute as needed...
|
|
|
*/
|
|
|
|
|
|
if (!strcmp(name, "marker-levels") || !strcmp(name, "marker-low-levels") ||
|
|
|
!strcmp(name, "marker-high-levels"))
|
|
|
{
|
|
|
/*
|
|
|
* Integer values...
|
|
|
*/
|
|
|
|
|
|
if ((attr = ippFindAttribute(p->attrs, name, IPP_TAG_INTEGER)) != NULL &&
|
|
|
attr->num_values < count)
|
|
|
{
|
|
|
ippDeleteAttribute(p->attrs, attr);
|
|
|
attr = NULL;
|
|
|
}
|
|
|
|
|
|
if (attr)
|
|
|
attr->num_values = count;
|
|
|
else
|
|
|
attr = ippAddIntegers(p->attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER, name,
|
|
|
count, NULL);
|
|
|
|
|
|
if (!attr)
|
|
|
{
|
|
|
free(temp);
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR,
|
|
|
"Unable to allocate memory for printer attribute "
|
|
|
"(%d values)", count);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
for (i = 0, start = temp; i < count; i ++)
|
|
|
{
|
|
|
if ((ptr = strchr(start, ',')) != NULL)
|
|
|
*ptr++ = '\0';
|
|
|
|
|
|
attr->values[i].integer = strtol(start, NULL, 10);
|
|
|
|
|
|
if (ptr)
|
|
|
start = ptr;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
/*
|
|
|
* Name or keyword values...
|
|
|
*/
|
|
|
|
|
|
if (!strcmp(name, "marker-types"))
|
|
|
value_tag = IPP_TAG_KEYWORD;
|
|
|
else if (!strcmp(name, "marker-message"))
|
|
|
value_tag = IPP_TAG_TEXT;
|
|
|
else
|
|
|
value_tag = IPP_TAG_NAME;
|
|
|
|
|
|
if ((attr = ippFindAttribute(p->attrs, name, value_tag)) != NULL &&
|
|
|
attr->num_values < count)
|
|
|
{
|
|
|
ippDeleteAttribute(p->attrs, attr);
|
|
|
attr = NULL;
|
|
|
}
|
|
|
|
|
|
if (attr)
|
|
|
{
|
|
|
for (i = 0; i < attr->num_values; i ++)
|
|
|
_cupsStrFree(attr->values[i].string.text);
|
|
|
|
|
|
attr->num_values = count;
|
|
|
}
|
|
|
else
|
|
|
attr = ippAddStrings(p->attrs, IPP_TAG_PRINTER, value_tag, name,
|
|
|
count, NULL, NULL);
|
|
|
|
|
|
if (!attr)
|
|
|
{
|
|
|
free(temp);
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR,
|
|
|
"Unable to allocate memory for printer attribute "
|
|
|
"(%d values)", count);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
for (i = 0, quote = '\0', ptr = temp; i < count; i ++)
|
|
|
{
|
|
|
for (start = ptr; *ptr; ptr ++)
|
|
|
{
|
|
|
if (*ptr == quote)
|
|
|
*ptr = quote = '\0';
|
|
|
else if (quote)
|
|
|
continue;
|
|
|
else if (*ptr == '\\' && ptr[1])
|
|
|
_cups_strcpy(ptr, ptr + 1);
|
|
|
else if (*ptr == '\'' || *ptr == '\"')
|
|
|
{
|
|
|
quote = *ptr;
|
|
|
|
|
|
if (ptr == start)
|
|
|
start ++;
|
|
|
else
|
|
|
_cups_strcpy(ptr, ptr + 1);
|
|
|
}
|
|
|
else if (*ptr == ',')
|
|
|
{
|
|
|
*ptr++ = '\0';
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
attr->values[i].string.text = _cupsStrAlloc(start);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
free(temp);
|
|
|
|
|
|
/*
|
|
|
* Update the printer-supply and printer-supply-description, as needed...
|
|
|
*/
|
|
|
|
|
|
if (!strcmp(name, "marker-names"))
|
|
|
{
|
|
|
ipp_attribute_t *supply_desc = ippFindAttribute(p->attrs, "printer-supply-description", IPP_TAG_TEXT);
|
|
|
/* printer-supply-description attribute */
|
|
|
|
|
|
if (supply_desc != NULL)
|
|
|
ippDeleteAttribute(p->attrs, supply_desc);
|
|
|
|
|
|
supply_desc = ippCopyAttribute(p->attrs, attr, 0);
|
|
|
ippSetName(p->attrs, &supply_desc, "printer-supply-description");
|
|
|
ippSetValueTag(p->attrs, &supply_desc, IPP_TAG_TEXT);
|
|
|
}
|
|
|
else if (!strcmp(name, "marker-colors") || !strcmp(name, "marker-levels") || !strcmp(name, "marker-types"))
|
|
|
{
|
|
|
char buffer[256], /* printer-supply values */
|
|
|
pstype[64], /* printer-supply type value */
|
|
|
*psptr; /* Pointer into type */
|
|
|
const char *color, /* marker-colors value */
|
|
|
*type; /* marker-types value */
|
|
|
int level; /* marker-levels value */
|
|
|
ipp_attribute_t *colors = ippFindAttribute(p->attrs, "marker-colors", IPP_TAG_NAME);
|
|
|
/* marker-colors attribute */
|
|
|
ipp_attribute_t *levels = ippFindAttribute(p->attrs, "marker-levels", IPP_TAG_INTEGER);
|
|
|
/* marker-levels attribute */
|
|
|
ipp_attribute_t *types = ippFindAttribute(p->attrs, "marker-types", IPP_TAG_KEYWORD);
|
|
|
/* marker-types attribute */
|
|
|
ipp_attribute_t *supply = ippFindAttribute(p->attrs, "printer-supply", IPP_TAG_STRING);
|
|
|
/* printer-supply attribute */
|
|
|
|
|
|
if (supply != NULL)
|
|
|
{
|
|
|
ippDeleteAttribute(p->attrs, supply);
|
|
|
supply = NULL;
|
|
|
}
|
|
|
|
|
|
if (!colors || !levels || !types)
|
|
|
return;
|
|
|
|
|
|
count = ippGetCount(colors);
|
|
|
if (count != ippGetCount(levels) || count != ippGetCount(types))
|
|
|
return;
|
|
|
|
|
|
for (i = 0; i < count; i ++)
|
|
|
{
|
|
|
color = ippGetString(colors, i, NULL);
|
|
|
level = ippGetInteger(levels, i);
|
|
|
type = ippGetString(types, i, NULL);
|
|
|
|
|
|
for (psptr = pstype; *type && psptr < (pstype + sizeof(pstype) - 1); type ++)
|
|
|
if (*type == '-')
|
|
|
{
|
|
|
type ++;
|
|
|
*psptr++ = (char)toupper(*type & 255);
|
|
|
}
|
|
|
else
|
|
|
*psptr++ = *type;
|
|
|
*psptr = '\0';
|
|
|
|
|
|
snprintf(buffer, sizeof(buffer), "index=%d;class=%s;type=%s;unit=percent;maxcapacity=100;level=%d;colorantname=%s;", i + 1, strncmp(pstype, "waste", 5) ? "supplyThatIsConsumed" : "receptacleThatIsFilled", pstype, level, color);
|
|
|
|
|
|
if (!i)
|
|
|
supply = ippAddOctetString(p->attrs, IPP_TAG_PRINTER, "printer-supply", buffer, (int)strlen(buffer));
|
|
|
else
|
|
|
ippSetOctetString(p->attrs, &supply, i, buffer, (int)strlen(buffer));
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdSetPrinterAttrs()' - Set printer attributes based upon the PPD file.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdSetPrinterAttrs(cupsd_printer_t *p)/* I - Printer to setup */
|
|
|
{
|
|
|
int i; /* Looping var */
|
|
|
char resource[HTTP_MAX_URI]; /* Resource portion of URI */
|
|
|
cupsd_location_t *auth; /* Pointer to authentication element */
|
|
|
const char *auth_supported; /* Authentication supported */
|
|
|
ipp_t *oldattrs; /* Old printer attributes */
|
|
|
ipp_attribute_t *attr; /* Attribute data */
|
|
|
char *name, /* Current user/group name */
|
|
|
*filter; /* Current filter */
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Make sure that we have the common attributes defined...
|
|
|
*/
|
|
|
|
|
|
if (!CommonData)
|
|
|
cupsdCreateCommonData();
|
|
|
|
|
|
_cupsRWLockWrite(&p->lock);
|
|
|
|
|
|
/*
|
|
|
* Clear out old filters, if any...
|
|
|
*/
|
|
|
|
|
|
delete_printer_filters(p);
|
|
|
|
|
|
/*
|
|
|
* Figure out the authentication that is required for the printer.
|
|
|
*/
|
|
|
|
|
|
auth_supported = "requesting-user-name";
|
|
|
|
|
|
if (p->type & CUPS_PRINTER_CLASS)
|
|
|
snprintf(resource, sizeof(resource), "/classes/%s", p->name);
|
|
|
else
|
|
|
snprintf(resource, sizeof(resource), "/printers/%s", p->name);
|
|
|
|
|
|
if ((auth = cupsdFindBest(resource, HTTP_POST)) == NULL ||
|
|
|
auth->type == CUPSD_AUTH_NONE)
|
|
|
auth = cupsdFindPolicyOp(p->op_policy_ptr, IPP_PRINT_JOB);
|
|
|
|
|
|
if (auth)
|
|
|
{
|
|
|
int auth_type; /* Authentication type */
|
|
|
|
|
|
|
|
|
if ((auth_type = auth->type) == CUPSD_AUTH_DEFAULT)
|
|
|
auth_type = cupsdDefaultAuthType();
|
|
|
|
|
|
if (auth_type == CUPSD_AUTH_BASIC)
|
|
|
auth_supported = "basic";
|
|
|
#ifdef HAVE_GSSAPI
|
|
|
else if (auth_type == CUPSD_AUTH_NEGOTIATE)
|
|
|
auth_supported = "negotiate";
|
|
|
#endif /* HAVE_GSSAPI */
|
|
|
|
|
|
if (auth_type != CUPSD_AUTH_NONE)
|
|
|
p->type |= CUPS_PRINTER_AUTHENTICATED;
|
|
|
else
|
|
|
p->type &= (cups_ptype_t)~CUPS_PRINTER_AUTHENTICATED;
|
|
|
}
|
|
|
else
|
|
|
p->type &= (cups_ptype_t)~CUPS_PRINTER_AUTHENTICATED;
|
|
|
|
|
|
/*
|
|
|
* Create the required IPP attributes for a printer...
|
|
|
*/
|
|
|
|
|
|
oldattrs = p->attrs;
|
|
|
p->attrs = ippNew();
|
|
|
|
|
|
ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"uri-authentication-supported", NULL, auth_supported);
|
|
|
ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"uri-security-supported", NULL, "none");
|
|
|
if (p->printer_id)
|
|
|
ippAddInteger(p->attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER, "printer-id", p->printer_id);
|
|
|
ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_NAME, "printer-name", NULL,
|
|
|
p->name);
|
|
|
ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_TEXT, "printer-location",
|
|
|
NULL, p->location ? p->location : "");
|
|
|
if (p->geo_location)
|
|
|
ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_URI, "printer-geo-location", NULL, p->geo_location);
|
|
|
else
|
|
|
ippAddOutOfBand(p->attrs, IPP_TAG_PRINTER, IPP_TAG_UNKNOWN, "printer-geo-location");
|
|
|
ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_TEXT, "printer-info",
|
|
|
NULL, p->info ? p->info : "");
|
|
|
ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_TEXT, "printer-organization", NULL, p->organization ? p->organization : "");
|
|
|
ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_TEXT, "printer-organizational-unit", NULL, p->organizational_unit ? p->organizational_unit : "");
|
|
|
ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_URI, "printer-uuid", NULL, p->uuid);
|
|
|
|
|
|
if (cupsArrayCount(p->users) > 0)
|
|
|
{
|
|
|
if (p->deny_users)
|
|
|
attr = ippAddStrings(p->attrs, IPP_TAG_PRINTER, IPP_TAG_NAME,
|
|
|
"requesting-user-name-denied",
|
|
|
cupsArrayCount(p->users), NULL, NULL);
|
|
|
else
|
|
|
attr = ippAddStrings(p->attrs, IPP_TAG_PRINTER, IPP_TAG_NAME,
|
|
|
"requesting-user-name-allowed",
|
|
|
cupsArrayCount(p->users), NULL, NULL);
|
|
|
|
|
|
for (i = 0, name = (char *)cupsArrayFirst(p->users);
|
|
|
name;
|
|
|
i ++, name = (char *)cupsArrayNext(p->users))
|
|
|
attr->values[i].string.text = _cupsStrAlloc(name);
|
|
|
}
|
|
|
|
|
|
ippAddInteger(p->attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
|
|
|
"job-quota-period", p->quota_period);
|
|
|
ippAddInteger(p->attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
|
|
|
"job-k-limit", p->k_limit);
|
|
|
ippAddInteger(p->attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
|
|
|
"job-page-limit", p->page_limit);
|
|
|
if (p->num_auth_info_required > 0 && strcmp(p->auth_info_required[0], "none"))
|
|
|
ippAddStrings(p->attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"auth-info-required", p->num_auth_info_required, NULL,
|
|
|
p->auth_info_required);
|
|
|
|
|
|
if (cupsArrayCount(Banners) > 0)
|
|
|
{
|
|
|
/*
|
|
|
* Setup the job-sheets-default attribute...
|
|
|
*/
|
|
|
|
|
|
attr = ippAddStrings(p->attrs, IPP_TAG_PRINTER, IPP_TAG_NAME,
|
|
|
"job-sheets-default", 2, NULL, NULL);
|
|
|
|
|
|
if (attr != NULL)
|
|
|
{
|
|
|
attr->values[0].string.text = _cupsStrAlloc(Classification ?
|
|
|
Classification : p->job_sheets[0]);
|
|
|
attr->values[1].string.text = _cupsStrAlloc(Classification ?
|
|
|
Classification : p->job_sheets[1]);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
p->raw = 0;
|
|
|
p->remote = 0;
|
|
|
|
|
|
/*
|
|
|
* Assign additional attributes depending on whether this is a printer
|
|
|
* or class...
|
|
|
*/
|
|
|
|
|
|
if (p->type & CUPS_PRINTER_CLASS)
|
|
|
{
|
|
|
p->raw = 1;
|
|
|
p->type &= (cups_ptype_t)~CUPS_PRINTER_OPTIONS;
|
|
|
|
|
|
/*
|
|
|
* Add class-specific attributes...
|
|
|
*/
|
|
|
|
|
|
ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_TEXT,
|
|
|
"printer-make-and-model", NULL, "Local Printer Class");
|
|
|
ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_URI, "device-uri", NULL,
|
|
|
"file:///dev/null");
|
|
|
|
|
|
if (p->num_printers > 0)
|
|
|
{
|
|
|
/*
|
|
|
* Add a list of member names; URIs are added in copy_printer_attrs...
|
|
|
*/
|
|
|
|
|
|
attr = ippAddStrings(p->attrs, IPP_TAG_PRINTER, IPP_TAG_NAME,
|
|
|
"member-names", p->num_printers, NULL, NULL);
|
|
|
p->type |= CUPS_PRINTER_OPTIONS;
|
|
|
|
|
|
for (i = 0; i < p->num_printers; i ++)
|
|
|
{
|
|
|
if (attr != NULL)
|
|
|
attr->values[i].string.text = _cupsStrAlloc(p->printers[i]->name);
|
|
|
|
|
|
p->type &= (cups_ptype_t)~CUPS_PRINTER_OPTIONS | p->printers[i]->type;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
/*
|
|
|
* Add printer-specific attributes...
|
|
|
*/
|
|
|
|
|
|
ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_URI, "device-uri", NULL,
|
|
|
p->sanitized_device_uri);
|
|
|
|
|
|
/*
|
|
|
* Assign additional attributes from the PPD file (if any)...
|
|
|
*/
|
|
|
|
|
|
load_ppd(p);
|
|
|
|
|
|
/*
|
|
|
* Add filters for printer...
|
|
|
*/
|
|
|
|
|
|
cupsdSetPrinterReasons(p, "-cups-missing-filter-warning,"
|
|
|
"cups-insecure-filter-warning");
|
|
|
|
|
|
if (p->pc && p->pc->filters)
|
|
|
{
|
|
|
for (filter = (char *)cupsArrayFirst(p->pc->filters);
|
|
|
filter;
|
|
|
filter = (char *)cupsArrayNext(p->pc->filters))
|
|
|
add_printer_filter(p, p->filetype, filter);
|
|
|
}
|
|
|
else if (!(p->type & CUPS_PRINTER_REMOTE))
|
|
|
{
|
|
|
/*
|
|
|
* Add a filter from application/vnd.cups-raw to printer/name to
|
|
|
* handle "raw" printing by users.
|
|
|
*/
|
|
|
|
|
|
add_printer_filter(p, p->filetype, "application/vnd.cups-raw 0 -");
|
|
|
|
|
|
/*
|
|
|
* Add a PostScript filter, since this is still possibly PS printer.
|
|
|
*/
|
|
|
|
|
|
add_printer_filter(p, p->filetype,
|
|
|
"application/vnd.cups-postscript 0 -");
|
|
|
}
|
|
|
|
|
|
if (p->pc && p->pc->prefilters)
|
|
|
{
|
|
|
if (!p->prefiltertype)
|
|
|
p->prefiltertype = mimeAddType(MimeDatabase, "prefilter", p->name);
|
|
|
|
|
|
for (filter = (char *)cupsArrayFirst(p->pc->prefilters);
|
|
|
filter;
|
|
|
filter = (char *)cupsArrayNext(p->pc->prefilters))
|
|
|
add_printer_filter(p, p->prefiltertype, filter);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Copy marker attributes as needed...
|
|
|
*/
|
|
|
|
|
|
if (oldattrs)
|
|
|
{
|
|
|
ipp_attribute_t *oldattr; /* Old attribute */
|
|
|
|
|
|
|
|
|
if ((oldattr = ippFindAttribute(oldattrs, "marker-colors",
|
|
|
IPP_TAG_NAME)) != NULL)
|
|
|
{
|
|
|
if ((attr = ippAddStrings(p->attrs, IPP_TAG_PRINTER, IPP_TAG_NAME,
|
|
|
"marker-colors", oldattr->num_values, NULL,
|
|
|
NULL)) != NULL)
|
|
|
{
|
|
|
for (i = 0; i < oldattr->num_values; i ++)
|
|
|
attr->values[i].string.text =
|
|
|
_cupsStrAlloc(oldattr->values[i].string.text);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if ((oldattr = ippFindAttribute(oldattrs, "marker-levels",
|
|
|
IPP_TAG_INTEGER)) != NULL)
|
|
|
{
|
|
|
if ((attr = ippAddIntegers(p->attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
|
|
|
"marker-levels", oldattr->num_values,
|
|
|
NULL)) != NULL)
|
|
|
{
|
|
|
for (i = 0; i < oldattr->num_values; i ++)
|
|
|
attr->values[i].integer = oldattr->values[i].integer;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if ((oldattr = ippFindAttribute(oldattrs, "marker-message",
|
|
|
IPP_TAG_TEXT)) != NULL)
|
|
|
ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_TEXT, "marker-message",
|
|
|
NULL, oldattr->values[0].string.text);
|
|
|
|
|
|
if ((oldattr = ippFindAttribute(oldattrs, "marker-low-levels",
|
|
|
IPP_TAG_INTEGER)) != NULL)
|
|
|
{
|
|
|
if ((attr = ippAddIntegers(p->attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
|
|
|
"marker-low-levels", oldattr->num_values,
|
|
|
NULL)) != NULL)
|
|
|
{
|
|
|
for (i = 0; i < oldattr->num_values; i ++)
|
|
|
attr->values[i].integer = oldattr->values[i].integer;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if ((oldattr = ippFindAttribute(oldattrs, "marker-high-levels",
|
|
|
IPP_TAG_INTEGER)) != NULL)
|
|
|
{
|
|
|
if ((attr = ippAddIntegers(p->attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
|
|
|
"marker-high-levels", oldattr->num_values,
|
|
|
NULL)) != NULL)
|
|
|
{
|
|
|
for (i = 0; i < oldattr->num_values; i ++)
|
|
|
attr->values[i].integer = oldattr->values[i].integer;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if ((oldattr = ippFindAttribute(oldattrs, "marker-names",
|
|
|
IPP_TAG_NAME)) != NULL)
|
|
|
{
|
|
|
if ((attr = ippAddStrings(p->attrs, IPP_TAG_PRINTER, IPP_TAG_NAME,
|
|
|
"marker-names", oldattr->num_values, NULL,
|
|
|
NULL)) != NULL)
|
|
|
{
|
|
|
for (i = 0; i < oldattr->num_values; i ++)
|
|
|
attr->values[i].string.text =
|
|
|
_cupsStrAlloc(oldattr->values[i].string.text);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if ((oldattr = ippFindAttribute(oldattrs, "marker-types",
|
|
|
IPP_TAG_KEYWORD)) != NULL)
|
|
|
{
|
|
|
if ((attr = ippAddStrings(p->attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"marker-types", oldattr->num_values, NULL,
|
|
|
NULL)) != NULL)
|
|
|
{
|
|
|
for (i = 0; i < oldattr->num_values; i ++)
|
|
|
attr->values[i].string.text =
|
|
|
_cupsStrAlloc(oldattr->values[i].string.text);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
ippDelete(oldattrs);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Force sharing off for remote queues...
|
|
|
*/
|
|
|
|
|
|
if (p->type & CUPS_PRINTER_REMOTE)
|
|
|
p->shared = 0;
|
|
|
|
|
|
/*
|
|
|
* Populate the document-format-supported attribute...
|
|
|
*/
|
|
|
|
|
|
add_printer_formats(p);
|
|
|
|
|
|
/*
|
|
|
* Add name-default attributes...
|
|
|
*/
|
|
|
|
|
|
add_printer_defaults(p);
|
|
|
|
|
|
_cupsRWUnlock(&p->lock);
|
|
|
|
|
|
/*
|
|
|
* Let the browse protocols reflect the change
|
|
|
*/
|
|
|
|
|
|
cupsdRegisterPrinter(p);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdSetPrinterReasons()' - Set/update the reasons strings.
|
|
|
*/
|
|
|
|
|
|
int /* O - 1 if something changed, 0 otherwise */
|
|
|
cupsdSetPrinterReasons(
|
|
|
cupsd_printer_t *p, /* I - Printer */
|
|
|
const char *s) /* I - Reasons strings */
|
|
|
{
|
|
|
int i, /* Looping var */
|
|
|
changed = 0; /* Did something change? */
|
|
|
const char *sptr; /* Pointer into reasons */
|
|
|
char reason[255], /* Reason string */
|
|
|
*rptr; /* Pointer into reason */
|
|
|
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2,
|
|
|
"cupsdSetPrinterReasons(p=%p(%s),s=\"%s\"", p, p->name, s);
|
|
|
|
|
|
if (s[0] == '-' || s[0] == '+')
|
|
|
{
|
|
|
/*
|
|
|
* Add/remove reasons...
|
|
|
*/
|
|
|
|
|
|
sptr = s + 1;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
/*
|
|
|
* Replace reasons...
|
|
|
*/
|
|
|
|
|
|
sptr = s;
|
|
|
|
|
|
for (i = 0; i < p->num_reasons; i ++)
|
|
|
_cupsStrFree(p->reasons[i]);
|
|
|
|
|
|
p->num_reasons = 0;
|
|
|
changed = 1;
|
|
|
|
|
|
dirty_printer(p);
|
|
|
}
|
|
|
|
|
|
if (!strcmp(s, "none"))
|
|
|
return (changed);
|
|
|
|
|
|
/*
|
|
|
* Loop through all of the reasons...
|
|
|
*/
|
|
|
|
|
|
while (*sptr)
|
|
|
{
|
|
|
/*
|
|
|
* Skip leading whitespace and commas...
|
|
|
*/
|
|
|
|
|
|
while (isspace(*sptr & 255) || *sptr == ',')
|
|
|
sptr ++;
|
|
|
|
|
|
for (rptr = reason; *sptr && !isspace(*sptr & 255) && *sptr != ','; sptr ++)
|
|
|
if (rptr < (reason + sizeof(reason) - 1))
|
|
|
*rptr++ = *sptr;
|
|
|
|
|
|
if (rptr == reason)
|
|
|
break;
|
|
|
|
|
|
*rptr = '\0';
|
|
|
|
|
|
if (s[0] == '-')
|
|
|
{
|
|
|
/*
|
|
|
* Remove reason...
|
|
|
*/
|
|
|
|
|
|
for (i = 0; i < p->num_reasons; i ++)
|
|
|
if (!strcmp(reason, p->reasons[i]))
|
|
|
{
|
|
|
/*
|
|
|
* Found a match, so remove it...
|
|
|
*/
|
|
|
|
|
|
p->num_reasons --;
|
|
|
changed = 1;
|
|
|
_cupsStrFree(p->reasons[i]);
|
|
|
|
|
|
if (i < p->num_reasons)
|
|
|
memmove(p->reasons + i, p->reasons + i + 1, (size_t)(p->num_reasons - i) * sizeof(char *));
|
|
|
|
|
|
if (!strcmp(reason, "paused") && p->state == IPP_PRINTER_STOPPED)
|
|
|
cupsdSetPrinterState(p, IPP_PRINTER_IDLE, 1);
|
|
|
|
|
|
if (!strcmp(reason, "cups-waiting-for-job-completed") && p->job)
|
|
|
p->job->completed = 0;
|
|
|
|
|
|
if (strcmp(reason, "connecting-to-device"))
|
|
|
dirty_printer(p);
|
|
|
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
else if (p->num_reasons < (int)(sizeof(p->reasons) / sizeof(p->reasons[0])))
|
|
|
{
|
|
|
/*
|
|
|
* Add reason...
|
|
|
*/
|
|
|
|
|
|
for (i = 0; i < p->num_reasons; i ++)
|
|
|
if (!strcmp(reason, p->reasons[i]))
|
|
|
break;
|
|
|
|
|
|
if (i >= p->num_reasons)
|
|
|
{
|
|
|
if (i >= (int)(sizeof(p->reasons) / sizeof(p->reasons[0])))
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_ALERT,
|
|
|
"Too many printer-state-reasons values for %s (%d)",
|
|
|
p->name, i + 1);
|
|
|
return (changed);
|
|
|
}
|
|
|
|
|
|
p->reasons[i] = _cupsStrAlloc(reason);
|
|
|
p->num_reasons ++;
|
|
|
changed = 1;
|
|
|
|
|
|
if (!strcmp(reason, "paused") && p->state != IPP_PRINTER_STOPPED)
|
|
|
cupsdSetPrinterState(p, IPP_PRINTER_STOPPED, 1);
|
|
|
|
|
|
if (!strcmp(reason, "cups-waiting-for-job-completed") && p->job)
|
|
|
p->job->completed = 1;
|
|
|
|
|
|
if (strcmp(reason, "connecting-to-device"))
|
|
|
dirty_printer(p);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return (changed);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdSetPrinterState()' - Update the current state of a printer.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdSetPrinterState(
|
|
|
cupsd_printer_t *p, /* I - Printer to change */
|
|
|
ipp_pstate_t s, /* I - New state */
|
|
|
int update) /* I - Update printers.conf? */
|
|
|
{
|
|
|
cupsd_job_t *job; /* Current job */
|
|
|
ipp_pstate_t old_state; /* Old printer state */
|
|
|
static const char * const printer_states[] =
|
|
|
{ /* State strings */
|
|
|
"idle",
|
|
|
"processing",
|
|
|
"stopped"
|
|
|
};
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Set the new state...
|
|
|
*/
|
|
|
|
|
|
old_state = p->state;
|
|
|
p->state = s;
|
|
|
|
|
|
if (old_state != s)
|
|
|
{
|
|
|
cupsdAddEvent(s == IPP_PRINTER_STOPPED ? CUPSD_EVENT_PRINTER_STOPPED :
|
|
|
CUPSD_EVENT_PRINTER_STATE, p, NULL,
|
|
|
"%s \"%s\" state changed to %s.",
|
|
|
(p->type & CUPS_PRINTER_CLASS) ? "Class" : "Printer",
|
|
|
p->name, printer_states[p->state - IPP_PRINTER_IDLE]);
|
|
|
|
|
|
/*
|
|
|
* Let the browse code know this needs to be updated...
|
|
|
*/
|
|
|
|
|
|
p->state_time = time(NULL);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Set/clear the paused reason as needed...
|
|
|
*/
|
|
|
|
|
|
if (s == IPP_PRINTER_STOPPED)
|
|
|
cupsdSetPrinterReasons(p, "+paused");
|
|
|
else
|
|
|
cupsdSetPrinterReasons(p, "-paused");
|
|
|
|
|
|
if (old_state != s)
|
|
|
{
|
|
|
for (job = (cupsd_job_t *)cupsArrayFirst(ActiveJobs);
|
|
|
job;
|
|
|
job = (cupsd_job_t *)cupsArrayNext(ActiveJobs))
|
|
|
if (job->reasons && job->state_value == IPP_JOB_PENDING &&
|
|
|
!_cups_strcasecmp(job->dest, p->name))
|
|
|
ippSetString(job->attrs, &job->reasons, 0,
|
|
|
s == IPP_PRINTER_STOPPED ? "printer-stopped" : "none");
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Clear the message for the queue when going to processing...
|
|
|
*/
|
|
|
|
|
|
if (s == IPP_PRINTER_PROCESSING)
|
|
|
p->state_message[0] = '\0';
|
|
|
|
|
|
/*
|
|
|
* Let the browse protocols reflect the change...
|
|
|
*/
|
|
|
|
|
|
if (update)
|
|
|
cupsdRegisterPrinter(p);
|
|
|
|
|
|
/*
|
|
|
* Save the printer configuration if a printer goes from idle or processing
|
|
|
* to stopped (or visa-versa)...
|
|
|
*/
|
|
|
|
|
|
if (update &&
|
|
|
(old_state == IPP_PRINTER_STOPPED) != (s == IPP_PRINTER_STOPPED))
|
|
|
dirty_printer(p);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdStopPrinter()' - Stop a printer from printing any jobs...
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdStopPrinter(cupsd_printer_t *p, /* I - Printer to stop */
|
|
|
int update)/* I - Update printers.conf? */
|
|
|
{
|
|
|
/*
|
|
|
* Set the printer state...
|
|
|
*/
|
|
|
|
|
|
cupsdSetPrinterState(p, IPP_PRINTER_STOPPED, update);
|
|
|
|
|
|
/*
|
|
|
* See if we have a job printing on this printer...
|
|
|
*/
|
|
|
|
|
|
if (p->job && p->job->state_value == IPP_JOB_PROCESSING)
|
|
|
cupsdSetJobState(p->job, IPP_JOB_PENDING, CUPSD_JOB_DEFAULT,
|
|
|
"Job stopped due to printer being paused.");
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdUpdatePrinterPPD()' - Update keywords in a printer's PPD file.
|
|
|
*/
|
|
|
|
|
|
int /* O - 1 if successful, 0 otherwise */
|
|
|
cupsdUpdatePrinterPPD(
|
|
|
cupsd_printer_t *p, /* I - Printer */
|
|
|
int num_keywords, /* I - Number of keywords */
|
|
|
cups_option_t *keywords) /* I - Keywords */
|
|
|
{
|
|
|
int i; /* Looping var */
|
|
|
cups_file_t *src, /* Original file */
|
|
|
*dst; /* New file */
|
|
|
char srcfile[1024], /* Original filename */
|
|
|
dstfile[1024], /* New filename */
|
|
|
line[1024], /* Line from file */
|
|
|
keystring[41]; /* Keyword from line */
|
|
|
cups_option_t *keyword; /* Current keyword */
|
|
|
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_INFO, "Updating keywords in PPD file for %s...",
|
|
|
p->name);
|
|
|
|
|
|
/*
|
|
|
* Get the old and new PPD filenames...
|
|
|
*/
|
|
|
|
|
|
snprintf(srcfile, sizeof(srcfile), "%s/ppd/%s.ppd.O", ServerRoot, p->name);
|
|
|
snprintf(dstfile, sizeof(srcfile), "%s/ppd/%s.ppd", ServerRoot, p->name);
|
|
|
|
|
|
/*
|
|
|
* Rename the old file and open the old and new...
|
|
|
*/
|
|
|
|
|
|
if (rename(dstfile, srcfile))
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR, "Unable to backup PPD file for %s: %s",
|
|
|
p->name, strerror(errno));
|
|
|
return (0);
|
|
|
}
|
|
|
|
|
|
if ((src = cupsFileOpen(srcfile, "r")) == NULL)
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR, "Unable to open PPD file \"%s\": %s",
|
|
|
srcfile, strerror(errno));
|
|
|
rename(srcfile, dstfile);
|
|
|
return (0);
|
|
|
}
|
|
|
|
|
|
if ((dst = cupsFileOpen(dstfile, "w")) == NULL)
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR, "Unable to create PPD file \"%s\": %s",
|
|
|
dstfile, strerror(errno));
|
|
|
cupsFileClose(src);
|
|
|
rename(srcfile, dstfile);
|
|
|
return (0);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Copy the first line and then write out all of the keywords...
|
|
|
*/
|
|
|
|
|
|
if (!cupsFileGets(src, line, sizeof(line)))
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR, "Unable to read PPD file \"%s\": %s",
|
|
|
srcfile, strerror(errno));
|
|
|
cupsFileClose(src);
|
|
|
cupsFileClose(dst);
|
|
|
rename(srcfile, dstfile);
|
|
|
return (0);
|
|
|
}
|
|
|
|
|
|
cupsFilePrintf(dst, "%s\n", line);
|
|
|
|
|
|
for (i = num_keywords, keyword = keywords; i > 0; i --, keyword ++)
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG, "*%s: %s", keyword->name, keyword->value);
|
|
|
cupsFilePrintf(dst, "*%s: %s\n", keyword->name, keyword->value);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Then copy the rest of the PPD file, dropping any keywords we changed.
|
|
|
*/
|
|
|
|
|
|
while (cupsFileGets(src, line, sizeof(line)))
|
|
|
{
|
|
|
/*
|
|
|
* Skip keywords we've already set...
|
|
|
*/
|
|
|
|
|
|
if (sscanf(line, "*%40[^:]:", keystring) == 1 &&
|
|
|
cupsGetOption(keystring, num_keywords, keywords))
|
|
|
continue;
|
|
|
|
|
|
/*
|
|
|
* Otherwise write the line...
|
|
|
*/
|
|
|
|
|
|
cupsFilePrintf(dst, "%s\n", line);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Close files and return...
|
|
|
*/
|
|
|
|
|
|
cupsFileClose(src);
|
|
|
cupsFileClose(dst);
|
|
|
|
|
|
return (1);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdUpdatePrinters()' - Update printers after a partial reload.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdUpdatePrinters(void)
|
|
|
{
|
|
|
cupsd_printer_t *p; /* Current printer */
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Loop through the printers and recreate the printer attributes
|
|
|
* for any local printers since the policy and/or access control
|
|
|
* stuff may have changed. Also, if browsing is disabled, remove
|
|
|
* any remote printers...
|
|
|
*/
|
|
|
|
|
|
for (p = (cupsd_printer_t *)cupsArrayFirst(Printers);
|
|
|
p;
|
|
|
p = (cupsd_printer_t *)cupsArrayNext(Printers))
|
|
|
{
|
|
|
/*
|
|
|
* Update the operation policy pointer...
|
|
|
*/
|
|
|
|
|
|
if ((p->op_policy_ptr = cupsdFindPolicy(p->op_policy)) == NULL)
|
|
|
p->op_policy_ptr = DefaultPolicyPtr;
|
|
|
|
|
|
/*
|
|
|
* Update printer attributes...
|
|
|
*/
|
|
|
|
|
|
cupsdSetPrinterAttrs(p);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdValidateDest()' - Validate a printer/class destination.
|
|
|
*/
|
|
|
|
|
|
const char * /* O - Printer or class name */
|
|
|
cupsdValidateDest(
|
|
|
const char *uri, /* I - Printer URI */
|
|
|
cups_ptype_t *dtype, /* O - Type (printer or class) */
|
|
|
cupsd_printer_t **printer) /* O - Printer pointer */
|
|
|
{
|
|
|
cupsd_printer_t *p; /* Current printer */
|
|
|
char localname[1024],/* Localized hostname */
|
|
|
*lptr, /* Pointer into localized hostname */
|
|
|
*sptr, /* Pointer into server name */
|
|
|
*rptr, /* Pointer into resource */
|
|
|
scheme[32], /* Scheme portion of URI */
|
|
|
username[64], /* Username portion of URI */
|
|
|
hostname[HTTP_MAX_HOST],
|
|
|
/* Host portion of URI */
|
|
|
resource[HTTP_MAX_URI];
|
|
|
/* Resource portion of URI */
|
|
|
int port; /* Port portion of URI */
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Initialize return values...
|
|
|
*/
|
|
|
|
|
|
if (printer)
|
|
|
*printer = NULL;
|
|
|
|
|
|
if (dtype)
|
|
|
*dtype = (cups_ptype_t)0;
|
|
|
|
|
|
/*
|
|
|
* Pull the hostname and resource from the URI...
|
|
|
*/
|
|
|
|
|
|
httpSeparateURI(HTTP_URI_CODING_ALL, uri, scheme, sizeof(scheme),
|
|
|
username, sizeof(username), hostname, sizeof(hostname),
|
|
|
&port, resource, sizeof(resource));
|
|
|
|
|
|
/*
|
|
|
* See if the resource is a class or printer...
|
|
|
*/
|
|
|
|
|
|
if (!strncmp(resource, "/classes/", 9))
|
|
|
{
|
|
|
/*
|
|
|
* Class...
|
|
|
*/
|
|
|
|
|
|
rptr = resource + 9;
|
|
|
}
|
|
|
else if (!strncmp(resource, "/printers/", 10))
|
|
|
{
|
|
|
/*
|
|
|
* Printer...
|
|
|
*/
|
|
|
|
|
|
rptr = resource + 10;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
/*
|
|
|
* Bad resource name...
|
|
|
*/
|
|
|
|
|
|
return (NULL);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* See if the printer or class name exists...
|
|
|
*/
|
|
|
|
|
|
p = cupsdFindDest(rptr);
|
|
|
|
|
|
if (p == NULL && strchr(rptr, '@') == NULL)
|
|
|
return (NULL);
|
|
|
else if (p != NULL)
|
|
|
{
|
|
|
if (printer)
|
|
|
*printer = p;
|
|
|
|
|
|
if (dtype)
|
|
|
*dtype = p->type & (CUPS_PRINTER_CLASS | CUPS_PRINTER_REMOTE);
|
|
|
|
|
|
return (p->name);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Change localhost to the server name...
|
|
|
*/
|
|
|
|
|
|
if (!_cups_strcasecmp(hostname, "localhost"))
|
|
|
strlcpy(hostname, ServerName, sizeof(hostname));
|
|
|
|
|
|
strlcpy(localname, hostname, sizeof(localname));
|
|
|
|
|
|
if (!_cups_strcasecmp(hostname, ServerName))
|
|
|
{
|
|
|
/*
|
|
|
* Localize the hostname...
|
|
|
*/
|
|
|
|
|
|
lptr = strchr(localname, '.');
|
|
|
sptr = strchr(ServerName, '.');
|
|
|
|
|
|
if (sptr != NULL && lptr != NULL)
|
|
|
{
|
|
|
/*
|
|
|
* Strip the common domain name components...
|
|
|
*/
|
|
|
|
|
|
while (lptr != NULL)
|
|
|
{
|
|
|
if (!_cups_strcasecmp(lptr, sptr))
|
|
|
{
|
|
|
*lptr = '\0';
|
|
|
break;
|
|
|
}
|
|
|
else
|
|
|
lptr = strchr(lptr + 1, '.');
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Find a matching printer or class...
|
|
|
*/
|
|
|
|
|
|
for (p = (cupsd_printer_t *)cupsArrayFirst(Printers);
|
|
|
p;
|
|
|
p = (cupsd_printer_t *)cupsArrayNext(Printers))
|
|
|
if (!_cups_strcasecmp(p->hostname, localname) &&
|
|
|
!_cups_strcasecmp(p->name, rptr))
|
|
|
{
|
|
|
if (printer)
|
|
|
*printer = p;
|
|
|
|
|
|
if (dtype)
|
|
|
*dtype = p->type & (CUPS_PRINTER_CLASS | CUPS_PRINTER_REMOTE);
|
|
|
|
|
|
return (p->name);
|
|
|
}
|
|
|
|
|
|
return (NULL);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdWritePrintcap()' - Write a pseudo-printcap file for older applications
|
|
|
* that need it...
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdWritePrintcap(void)
|
|
|
{
|
|
|
int i; /* Looping var */
|
|
|
cups_file_t *fp; /* Printcap file */
|
|
|
cupsd_printer_t *p; /* Current printer */
|
|
|
|
|
|
|
|
|
/*
|
|
|
* See if we have a printcap file; if not, don't bother writing it.
|
|
|
*/
|
|
|
|
|
|
if (!Printcap || !*Printcap)
|
|
|
return;
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_INFO, "Generating printcap %s...", Printcap);
|
|
|
|
|
|
/*
|
|
|
* Open the printcap file...
|
|
|
*/
|
|
|
|
|
|
if ((fp = cupsFileOpen(Printcap, "w")) == NULL)
|
|
|
return;
|
|
|
|
|
|
/*
|
|
|
* Put a comment header at the top so that users will know where the
|
|
|
* data has come from...
|
|
|
*/
|
|
|
|
|
|
if (PrintcapFormat != PRINTCAP_PLIST)
|
|
|
cupsFilePrintf(fp, "# This file was automatically generated by cupsd(8) "
|
|
|
"from the\n"
|
|
|
"# %s/printers.conf file. All changes to this file\n"
|
|
|
"# will be lost.\n", ServerRoot);
|
|
|
|
|
|
/*
|
|
|
* Write a new printcap with the current list of printers.
|
|
|
*/
|
|
|
|
|
|
switch (PrintcapFormat)
|
|
|
{
|
|
|
case PRINTCAP_BSD :
|
|
|
/*
|
|
|
* Each printer is put in the file as:
|
|
|
*
|
|
|
* Printer1:
|
|
|
* Printer2:
|
|
|
* Printer3:
|
|
|
* ...
|
|
|
* PrinterN:
|
|
|
*/
|
|
|
|
|
|
if (DefaultPrinter)
|
|
|
cupsFilePrintf(fp, "%s|%s:rm=%s:rp=%s:\n", DefaultPrinter->name,
|
|
|
DefaultPrinter->info, ServerName,
|
|
|
DefaultPrinter->name);
|
|
|
|
|
|
for (p = (cupsd_printer_t *)cupsArrayFirst(Printers);
|
|
|
p;
|
|
|
p = (cupsd_printer_t *)cupsArrayNext(Printers))
|
|
|
if (p != DefaultPrinter)
|
|
|
cupsFilePrintf(fp, "%s|%s:rm=%s:rp=%s:\n", p->name, p->info,
|
|
|
ServerName, p->name);
|
|
|
break;
|
|
|
|
|
|
case PRINTCAP_PLIST :
|
|
|
/*
|
|
|
* Each printer is written as a dictionary in a plist file.
|
|
|
* Currently the printer-name, printer-info, printer-is-accepting-jobs,
|
|
|
* printer-location, printer-make-and-model, printer-state,
|
|
|
* printer-state-reasons, printer-type, and (sanitized) device-uri.
|
|
|
*/
|
|
|
|
|
|
cupsFilePuts(fp, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
|
|
|
"<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD "
|
|
|
"PLIST 1.0//EN\" \"http://www.apple.com/DTDs/"
|
|
|
"PropertyList-1.0.dtd\">\n"
|
|
|
"<plist version=\"1.0\">\n"
|
|
|
"<array>\n");
|
|
|
|
|
|
for (p = (cupsd_printer_t *)cupsArrayFirst(Printers);
|
|
|
p;
|
|
|
p = (cupsd_printer_t *)cupsArrayNext(Printers))
|
|
|
{
|
|
|
cupsFilePuts(fp, "\t<dict>\n"
|
|
|
"\t\t<key>printer-name</key>\n"
|
|
|
"\t\t<string>");
|
|
|
write_xml_string(fp, p->name);
|
|
|
cupsFilePuts(fp, "</string>\n"
|
|
|
"\t\t<key>printer-info</key>\n"
|
|
|
"\t\t<string>");
|
|
|
write_xml_string(fp, p->info);
|
|
|
cupsFilePrintf(fp, "</string>\n"
|
|
|
"\t\t<key>printer-is-accepting-jobs</key>\n"
|
|
|
"\t\t<%s/>\n"
|
|
|
"\t\t<key>printer-location</key>\n"
|
|
|
"\t\t<string>", p->accepting ? "true" : "false");
|
|
|
write_xml_string(fp, p->location);
|
|
|
cupsFilePuts(fp, "</string>\n"
|
|
|
"\t\t<key>printer-make-and-model</key>\n"
|
|
|
"\t\t<string>");
|
|
|
write_xml_string(fp, p->make_model);
|
|
|
cupsFilePrintf(fp, "</string>\n"
|
|
|
"\t\t<key>printer-state</key>\n"
|
|
|
"\t\t<integer>%d</integer>\n"
|
|
|
"\t\t<key>printer-state-reasons</key>\n"
|
|
|
"\t\t<array>\n", p->state);
|
|
|
for (i = 0; i < p->num_reasons; i ++)
|
|
|
{
|
|
|
cupsFilePuts(fp, "\t\t\t<string>");
|
|
|
write_xml_string(fp, p->reasons[i]);
|
|
|
cupsFilePuts(fp, "</string>\n");
|
|
|
}
|
|
|
cupsFilePrintf(fp, "\t\t</array>\n"
|
|
|
"\t\t<key>printer-type</key>\n"
|
|
|
"\t\t<integer>%d</integer>\n"
|
|
|
"\t\t<key>device-uri</key>\n"
|
|
|
"\t\t<string>", p->type);
|
|
|
write_xml_string(fp, p->sanitized_device_uri);
|
|
|
cupsFilePuts(fp, "</string>\n"
|
|
|
"\t</dict>\n");
|
|
|
}
|
|
|
cupsFilePuts(fp, "</array>\n"
|
|
|
"</plist>\n");
|
|
|
break;
|
|
|
|
|
|
case PRINTCAP_SOLARIS :
|
|
|
/*
|
|
|
* Each printer is put in the file as:
|
|
|
*
|
|
|
* _all:all=Printer1,Printer2,Printer3,...,PrinterN
|
|
|
* _default:use=DefaultPrinter
|
|
|
* Printer1:\
|
|
|
* :bsdaddr=ServerName,Printer1:\
|
|
|
* :description=Description:
|
|
|
* Printer2:
|
|
|
* :bsdaddr=ServerName,Printer2:\
|
|
|
* :description=Description:
|
|
|
* Printer3:
|
|
|
* :bsdaddr=ServerName,Printer3:\
|
|
|
* :description=Description:
|
|
|
* ...
|
|
|
* PrinterN:
|
|
|
* :bsdaddr=ServerName,PrinterN:\
|
|
|
* :description=Description:
|
|
|
*/
|
|
|
|
|
|
cupsFilePuts(fp, "_all:all=");
|
|
|
for (p = (cupsd_printer_t *)cupsArrayFirst(Printers);
|
|
|
p;
|
|
|
p = (cupsd_printer_t *)cupsArrayCurrent(Printers))
|
|
|
cupsFilePrintf(fp, "%s%c", p->name,
|
|
|
cupsArrayNext(Printers) ? ',' : '\n');
|
|
|
|
|
|
if (DefaultPrinter)
|
|
|
cupsFilePrintf(fp, "_default:use=%s\n", DefaultPrinter->name);
|
|
|
|
|
|
for (p = (cupsd_printer_t *)cupsArrayFirst(Printers);
|
|
|
p;
|
|
|
p = (cupsd_printer_t *)cupsArrayNext(Printers))
|
|
|
cupsFilePrintf(fp, "%s:\\\n"
|
|
|
"\t:bsdaddr=%s,%s:\\\n"
|
|
|
"\t:description=%s:\n",
|
|
|
p->name, ServerName, p->name,
|
|
|
p->info ? p->info : "");
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Close the file...
|
|
|
*/
|
|
|
|
|
|
cupsFileClose(fp);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'add_printer_defaults()' - Add name-default attributes to the printer attributes.
|
|
|
*/
|
|
|
|
|
|
static void
|
|
|
add_printer_defaults(cupsd_printer_t *p)/* I - Printer */
|
|
|
{
|
|
|
int i; /* Looping var */
|
|
|
int num_options; /* Number of default options */
|
|
|
cups_option_t *options, /* Default options */
|
|
|
*option; /* Current option */
|
|
|
char name[256]; /* name-default */
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Maintain a common array of default attribute names...
|
|
|
*/
|
|
|
|
|
|
if (!CommonDefaults)
|
|
|
{
|
|
|
CommonDefaults = cupsArrayNew((cups_array_func_t)strcmp, NULL);
|
|
|
|
|
|
cupsArrayAdd(CommonDefaults, _cupsStrAlloc("copies-default"));
|
|
|
cupsArrayAdd(CommonDefaults, _cupsStrAlloc("document-format-default"));
|
|
|
cupsArrayAdd(CommonDefaults, _cupsStrAlloc("finishings-default"));
|
|
|
cupsArrayAdd(CommonDefaults, _cupsStrAlloc("job-account-id-default"));
|
|
|
cupsArrayAdd(CommonDefaults, _cupsStrAlloc("job-accounting-user-id-default"));
|
|
|
cupsArrayAdd(CommonDefaults, _cupsStrAlloc("job-cancel-after-default"));
|
|
|
cupsArrayAdd(CommonDefaults, _cupsStrAlloc("job-hold-until-default"));
|
|
|
cupsArrayAdd(CommonDefaults, _cupsStrAlloc("job-priority-default"));
|
|
|
cupsArrayAdd(CommonDefaults, _cupsStrAlloc("job-sheets-default"));
|
|
|
cupsArrayAdd(CommonDefaults, _cupsStrAlloc("media-col-default"));
|
|
|
cupsArrayAdd(CommonDefaults, _cupsStrAlloc("notify-lease-duration-default"));
|
|
|
cupsArrayAdd(CommonDefaults, _cupsStrAlloc("notify-events-default"));
|
|
|
cupsArrayAdd(CommonDefaults, _cupsStrAlloc("number-up-default"));
|
|
|
cupsArrayAdd(CommonDefaults, _cupsStrAlloc("orientation-requested-default"));
|
|
|
cupsArrayAdd(CommonDefaults, _cupsStrAlloc("print-quality-default"));
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Add all of the default options from the .conf files...
|
|
|
*/
|
|
|
|
|
|
for (num_options = 0, options = NULL, i = p->num_options, option = p->options;
|
|
|
i > 0;
|
|
|
i --, option ++)
|
|
|
{
|
|
|
if (strcmp(option->name, "ipp-options") &&
|
|
|
strcmp(option->name, "job-sheets") &&
|
|
|
strcmp(option->name, "lease-duration"))
|
|
|
{
|
|
|
snprintf(name, sizeof(name), "%s-default", option->name);
|
|
|
num_options = cupsAddOption(name, option->value, num_options, &options);
|
|
|
|
|
|
if (!cupsArrayFind(CommonDefaults, name))
|
|
|
cupsArrayAdd(CommonDefaults, _cupsStrAlloc(name));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Convert options to IPP attributes...
|
|
|
*/
|
|
|
|
|
|
cupsEncodeOptions2(p->attrs, num_options, options, IPP_TAG_PRINTER);
|
|
|
cupsFreeOptions(num_options, options);
|
|
|
|
|
|
/*
|
|
|
* Add standard -default attributes as needed...
|
|
|
*/
|
|
|
|
|
|
if (!cupsGetOption("copies", p->num_options, p->options))
|
|
|
ippAddInteger(p->attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER, "copies-default",
|
|
|
1);
|
|
|
|
|
|
if (!cupsGetOption("document-format", p->num_options, p->options))
|
|
|
ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_MIMETYPE,
|
|
|
"document-format-default", NULL, "application/octet-stream");
|
|
|
|
|
|
if (!cupsGetOption("job-cancel-after", p->num_options, p->options))
|
|
|
ippAddInteger(p->attrs, IPP_TAG_PRINTER, MaxJobTime > 0 ? IPP_TAG_INTEGER : IPP_TAG_NOVALUE,
|
|
|
"job-cancel-after-default", MaxJobTime);
|
|
|
|
|
|
if (!cupsGetOption("job-hold-until", p->num_options, p->options))
|
|
|
ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"job-hold-until-default", NULL, "no-hold");
|
|
|
|
|
|
if (!cupsGetOption("job-priority", p->num_options, p->options))
|
|
|
ippAddInteger(p->attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
|
|
|
"job-priority-default", 50);
|
|
|
|
|
|
if (!cupsGetOption("number-up", p->num_options, p->options))
|
|
|
ippAddInteger(p->attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
|
|
|
"number-up-default", 1);
|
|
|
|
|
|
if (!cupsGetOption("notify-lease-duration", p->num_options, p->options))
|
|
|
ippAddInteger(p->attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
|
|
|
"notify-lease-duration-default", DefaultLeaseDuration);
|
|
|
|
|
|
if (!cupsGetOption("notify-events", p->num_options, p->options))
|
|
|
ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"notify-events-default", NULL, "job-completed");
|
|
|
|
|
|
if (!cupsGetOption("orientation-requested", p->num_options, p->options))
|
|
|
ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_NOVALUE,
|
|
|
"orientation-requested-default", NULL, NULL);
|
|
|
|
|
|
if (!cupsGetOption("print-quality", p->num_options, p->options))
|
|
|
ippAddInteger(p->attrs, IPP_TAG_PRINTER, IPP_TAG_ENUM,
|
|
|
"print-quality-default", IPP_QUALITY_NORMAL);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'add_printer_filter()' - Add a MIME filter for a printer.
|
|
|
*/
|
|
|
|
|
|
static void
|
|
|
add_printer_filter(
|
|
|
cupsd_printer_t *p, /* I - Printer to add to */
|
|
|
mime_type_t *filtertype, /* I - Filter or prefilter MIME type */
|
|
|
const char *filter) /* I - Filter to add */
|
|
|
{
|
|
|
char super[MIME_MAX_SUPER], /* Super-type for filter */
|
|
|
type[MIME_MAX_TYPE], /* Type for filter */
|
|
|
dsuper[MIME_MAX_SUPER], /* Destination super-type for filter */
|
|
|
dtype[MIME_MAX_TYPE], /* Destination type for filter */
|
|
|
dest[MIME_MAX_SUPER + MIME_MAX_TYPE + 2],
|
|
|
/* Destination super/type */
|
|
|
program[1024]; /* Program/filter name */
|
|
|
int cost; /* Cost of filter */
|
|
|
size_t maxsize = 0; /* Maximum supported file size */
|
|
|
mime_type_t *temptype, /* MIME type looping var */
|
|
|
*desttype; /* Destination MIME type */
|
|
|
mime_filter_t *filterptr; /* MIME filter */
|
|
|
char filename[1024]; /* Full filter filename */
|
|
|
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2,
|
|
|
"add_printer_filter(p=%p(%s), filtertype=%p(%s/%s), "
|
|
|
"filter=\"%s\")", p, p->name, filtertype, filtertype->super,
|
|
|
filtertype->type, filter);
|
|
|
|
|
|
/*
|
|
|
* Parse the filter string; it should be in one of the following formats:
|
|
|
*
|
|
|
* source/type cost program
|
|
|
* source/type cost maxsize(nnnn) program
|
|
|
* source/type dest/type cost program
|
|
|
* source/type dest/type cost maxsize(nnnn) program
|
|
|
*/
|
|
|
|
|
|
if (sscanf(filter, "%15[^/]/%255s%*[ \t]%15[^/]/%255s%d%*[ \t]%1023[^\n]",
|
|
|
super, type, dsuper, dtype, &cost, program) == 6)
|
|
|
{
|
|
|
snprintf(dest, sizeof(dest), "%s/%s/%s", p->name, dsuper, dtype);
|
|
|
|
|
|
if ((desttype = mimeType(MimeDatabase, "printer", dest)) == NULL)
|
|
|
{
|
|
|
desttype = mimeAddType(MimeDatabase, "printer", dest);
|
|
|
if (!p->dest_types)
|
|
|
p->dest_types = cupsArrayNew(NULL, NULL);
|
|
|
|
|
|
cupsArrayAdd(p->dest_types, desttype);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (sscanf(filter, "%15[^/]/%255s%d%*[ \t]%1023[^\n]", super, type, &cost,
|
|
|
program) == 4)
|
|
|
{
|
|
|
desttype = filtertype;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR, "%s: invalid filter string \"%s\"!",
|
|
|
p->name, filter);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (!strncmp(program, "maxsize(", 8))
|
|
|
{
|
|
|
char *ptr; /* Pointer into maxsize(nnnn) program */
|
|
|
|
|
|
maxsize = (size_t)strtoll(program + 8, &ptr, 10);
|
|
|
|
|
|
if (*ptr != ')')
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR, "%s: invalid filter string \"%s\"!",
|
|
|
p->name, filter);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
ptr ++;
|
|
|
while (_cups_isspace(*ptr))
|
|
|
ptr ++;
|
|
|
|
|
|
_cups_strcpy(program, ptr);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Check permissions on the filter and its containing directory...
|
|
|
*/
|
|
|
|
|
|
if (strcmp(program, "-"))
|
|
|
{
|
|
|
if (program[0] == '/')
|
|
|
strlcpy(filename, program, sizeof(filename));
|
|
|
else
|
|
|
snprintf(filename, sizeof(filename), "%s/filter/%s", ServerBin, program);
|
|
|
|
|
|
_cupsFileCheck(filename, _CUPS_FILE_CHECK_PROGRAM, !RunUser,
|
|
|
cupsdLogFCMessage, p);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Add the filter to the MIME database, supporting wildcards as needed...
|
|
|
*/
|
|
|
|
|
|
for (temptype = mimeFirstType(MimeDatabase);
|
|
|
temptype;
|
|
|
temptype = mimeNextType(MimeDatabase))
|
|
|
if (((super[0] == '*' && _cups_strcasecmp(temptype->super, "printer")) ||
|
|
|
!_cups_strcasecmp(temptype->super, super)) &&
|
|
|
(type[0] == '*' || !_cups_strcasecmp(temptype->type, type)))
|
|
|
{
|
|
|
if (desttype != filtertype)
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2,
|
|
|
"add_printer_filter: %s: adding filter %s/%s %s/%s %d "
|
|
|
"%s", p->name, temptype->super, temptype->type,
|
|
|
desttype->super, desttype->type,
|
|
|
cost, program);
|
|
|
filterptr = mimeAddFilter(MimeDatabase, temptype, desttype, cost,
|
|
|
program);
|
|
|
|
|
|
if (!mimeFilterLookup(MimeDatabase, desttype, filtertype))
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2,
|
|
|
"add_printer_filter: %s: adding filter %s/%s %s/%s "
|
|
|
"0 -", p->name, desttype->super, desttype->type,
|
|
|
filtertype->super, filtertype->type);
|
|
|
mimeAddFilter(MimeDatabase, desttype, filtertype, 0, "-");
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2,
|
|
|
"add_printer_filter: %s: adding filter %s/%s %s/%s %d "
|
|
|
"%s", p->name, temptype->super, temptype->type,
|
|
|
filtertype->super, filtertype->type,
|
|
|
cost, program);
|
|
|
filterptr = mimeAddFilter(MimeDatabase, temptype, filtertype, cost,
|
|
|
program);
|
|
|
}
|
|
|
|
|
|
if (filterptr)
|
|
|
filterptr->maxsize = maxsize;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'add_printer_formats()' - Add document-format-supported values for a printer.
|
|
|
*/
|
|
|
|
|
|
static void
|
|
|
add_printer_formats(cupsd_printer_t *p) /* I - Printer */
|
|
|
{
|
|
|
int i; /* Looping var */
|
|
|
mime_type_t *type; /* Current MIME type */
|
|
|
cups_array_t *filters; /* Filters */
|
|
|
ipp_attribute_t *attr; /* document-format-supported attribute */
|
|
|
char mimetype[MIME_MAX_SUPER + MIME_MAX_TYPE + 2];
|
|
|
/* MIME type name */
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Raw (and remote) queues advertise all of the supported MIME
|
|
|
* types...
|
|
|
*/
|
|
|
|
|
|
cupsArrayDelete(p->filetypes);
|
|
|
p->filetypes = NULL;
|
|
|
|
|
|
if (p->raw)
|
|
|
{
|
|
|
ippAddStrings(p->attrs, IPP_TAG_PRINTER,
|
|
|
(ipp_tag_t)(IPP_TAG_MIMETYPE | IPP_TAG_COPY),
|
|
|
"document-format-supported", NumMimeTypes, NULL, MimeTypes);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Otherwise, loop through the supported MIME types and see if there
|
|
|
* are filters for them...
|
|
|
*/
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2, "add_printer_formats: %d types, %d filters",
|
|
|
mimeNumTypes(MimeDatabase), mimeNumFilters(MimeDatabase));
|
|
|
|
|
|
p->filetypes = cupsArrayNew(NULL, NULL);
|
|
|
|
|
|
for (type = mimeFirstType(MimeDatabase);
|
|
|
type;
|
|
|
type = mimeNextType(MimeDatabase))
|
|
|
{
|
|
|
if (!_cups_strcasecmp(type->super, "printer"))
|
|
|
continue;
|
|
|
|
|
|
snprintf(mimetype, sizeof(mimetype), "%s/%s", type->super, type->type);
|
|
|
|
|
|
if ((filters = mimeFilter(MimeDatabase, type, p->filetype, NULL)) != NULL)
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2,
|
|
|
"add_printer_formats: %s: %s needs %d filters",
|
|
|
p->name, mimetype, cupsArrayCount(filters));
|
|
|
|
|
|
cupsArrayDelete(filters);
|
|
|
cupsArrayAdd(p->filetypes, type);
|
|
|
}
|
|
|
else
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2,
|
|
|
"add_printer_formats: %s: %s not supported",
|
|
|
p->name, mimetype);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Add the file formats that can be filtered...
|
|
|
*/
|
|
|
|
|
|
if ((type = mimeType(MimeDatabase, "application", "octet-stream")) == NULL ||
|
|
|
!cupsArrayFind(p->filetypes, type))
|
|
|
i = 1;
|
|
|
else
|
|
|
i = 0;
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2,
|
|
|
"add_printer_formats: %s: %d supported types",
|
|
|
p->name, cupsArrayCount(p->filetypes) + i);
|
|
|
|
|
|
attr = ippAddStrings(p->attrs, IPP_TAG_PRINTER, IPP_TAG_MIMETYPE,
|
|
|
"document-format-supported",
|
|
|
cupsArrayCount(p->filetypes) + i, NULL, NULL);
|
|
|
|
|
|
if (i)
|
|
|
attr->values[0].string.text = _cupsStrAlloc("application/octet-stream");
|
|
|
|
|
|
for (type = (mime_type_t *)cupsArrayFirst(p->filetypes);
|
|
|
type;
|
|
|
i ++, type = (mime_type_t *)cupsArrayNext(p->filetypes))
|
|
|
{
|
|
|
snprintf(mimetype, sizeof(mimetype), "%s/%s", type->super, type->type);
|
|
|
|
|
|
attr->values[i].string.text = _cupsStrAlloc(mimetype);
|
|
|
}
|
|
|
|
|
|
#if defined(HAVE_DNSSD) || defined(HAVE_AVAHI)
|
|
|
{
|
|
|
char pdl[1024]; /* Buffer to build pdl list */
|
|
|
mime_filter_t *filter; /* MIME filter looping var */
|
|
|
|
|
|
|
|
|
/*
|
|
|
* We only support raw printing if this is not a Tioga PrintJobMgr based
|
|
|
* queue and if application/octet-stream is a known type...
|
|
|
*/
|
|
|
|
|
|
for (filter = (mime_filter_t *)cupsArrayFirst(MimeDatabase->filters);
|
|
|
filter;
|
|
|
filter = (mime_filter_t *)cupsArrayNext(MimeDatabase->filters))
|
|
|
{
|
|
|
if (filter->dst == p->filetype && strstr(filter->filter, "PrintJobMgr"))
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
pdl[0] = '\0';
|
|
|
|
|
|
if (!filter && mimeType(MimeDatabase, "application", "octet-stream"))
|
|
|
strlcat(pdl, "application/octet-stream,", sizeof(pdl));
|
|
|
|
|
|
/*
|
|
|
* Then list a bunch of formats that are supported by the printer...
|
|
|
*/
|
|
|
|
|
|
for (type = (mime_type_t *)cupsArrayFirst(p->filetypes);
|
|
|
type;
|
|
|
type = (mime_type_t *)cupsArrayNext(p->filetypes))
|
|
|
{
|
|
|
if (!_cups_strcasecmp(type->super, "application"))
|
|
|
{
|
|
|
if (!_cups_strcasecmp(type->type, "pdf"))
|
|
|
strlcat(pdl, "application/pdf,", sizeof(pdl));
|
|
|
else if (!_cups_strcasecmp(type->type, "postscript"))
|
|
|
strlcat(pdl, "application/postscript,", sizeof(pdl));
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(type->super, "image"))
|
|
|
{
|
|
|
if (!_cups_strcasecmp(type->type, "jpeg"))
|
|
|
strlcat(pdl, "image/jpeg,", sizeof(pdl));
|
|
|
else if (!_cups_strcasecmp(type->type, "png"))
|
|
|
strlcat(pdl, "image/png,", sizeof(pdl));
|
|
|
else if (!_cups_strcasecmp(type->type, "pwg-raster"))
|
|
|
strlcat(pdl, "image/pwg-raster,", sizeof(pdl));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (pdl[0])
|
|
|
pdl[strlen(pdl) - 1] = '\0'; /* Remove trailing comma */
|
|
|
|
|
|
cupsdSetString(&p->pdl, pdl);
|
|
|
}
|
|
|
#endif /* HAVE_DNSSD || HAVE_AVAHI */
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'compare_printers()' - Compare two printers.
|
|
|
*/
|
|
|
|
|
|
static int /* O - Result of comparison */
|
|
|
compare_printers(void *first, /* I - First printer */
|
|
|
void *second, /* I - Second printer */
|
|
|
void *data) /* I - App data (not used) */
|
|
|
{
|
|
|
(void)data;
|
|
|
|
|
|
return (_cups_strcasecmp(((cupsd_printer_t *)first)->name,
|
|
|
((cupsd_printer_t *)second)->name));
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'delete_printer_filters()' - Delete all MIME filters for a printer.
|
|
|
*/
|
|
|
|
|
|
static void
|
|
|
delete_printer_filters(
|
|
|
cupsd_printer_t *p) /* I - Printer to remove from */
|
|
|
{
|
|
|
mime_filter_t *filter; /* MIME filter looping var */
|
|
|
mime_type_t *type; /* Destination types for filters */
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Range check input...
|
|
|
*/
|
|
|
|
|
|
if (p == NULL)
|
|
|
return;
|
|
|
|
|
|
/*
|
|
|
* Remove all filters from the MIME database that have a destination
|
|
|
* type == printer...
|
|
|
*/
|
|
|
|
|
|
for (filter = mimeFirstFilter(MimeDatabase);
|
|
|
filter;
|
|
|
filter = mimeNextFilter(MimeDatabase))
|
|
|
if (filter->dst == p->filetype || filter->dst == p->prefiltertype ||
|
|
|
cupsArrayFind(p->dest_types, filter->dst))
|
|
|
{
|
|
|
/*
|
|
|
* Delete the current filter...
|
|
|
*/
|
|
|
|
|
|
mimeDeleteFilter(MimeDatabase, filter);
|
|
|
}
|
|
|
|
|
|
for (type = (mime_type_t *)cupsArrayFirst(p->dest_types);
|
|
|
type;
|
|
|
type = (mime_type_t *)cupsArrayNext(p->dest_types))
|
|
|
mimeDeleteType(MimeDatabase, type);
|
|
|
|
|
|
cupsArrayDelete(p->dest_types);
|
|
|
p->dest_types = NULL;
|
|
|
|
|
|
cupsdSetPrinterReasons(p, "-cups-insecure-filter-warning"
|
|
|
",cups-missing-filter-warning");
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'dirty_printer()' - Mark config and state files dirty for the specified
|
|
|
* printer.
|
|
|
*/
|
|
|
|
|
|
static void
|
|
|
dirty_printer(cupsd_printer_t *p) /* I - Printer */
|
|
|
{
|
|
|
if (p->type & CUPS_PRINTER_CLASS)
|
|
|
cupsdMarkDirty(CUPSD_DIRTY_CLASSES);
|
|
|
else
|
|
|
cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
|
|
|
|
|
|
if (PrintcapFormat == PRINTCAP_PLIST)
|
|
|
cupsdMarkDirty(CUPSD_DIRTY_PRINTCAP);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'load_ppd()' - Load a cached PPD file, updating the cache as needed.
|
|
|
*/
|
|
|
|
|
|
static void
|
|
|
load_ppd(cupsd_printer_t *p) /* I - Printer */
|
|
|
{
|
|
|
int i, j; /* Looping vars */
|
|
|
char cache_name[1024]; /* Cache filename */
|
|
|
struct stat cache_info; /* Cache file info */
|
|
|
ppd_file_t *ppd; /* PPD file */
|
|
|
char ppd_name[1024]; /* PPD filename */
|
|
|
struct stat ppd_info; /* PPD file info */
|
|
|
char strings_name[1024]; /* Strings filename */
|
|
|
int num_media; /* Number of media values */
|
|
|
ppd_size_t *size; /* Current PPD size */
|
|
|
ppd_option_t *duplex, /* Duplex option */
|
|
|
*output_bin, /* OutputBin option */
|
|
|
*output_mode, /* OutputMode option */
|
|
|
*resolution; /* (Set|JCL|)Resolution option */
|
|
|
ppd_choice_t *choice; /* Current PPD choice */
|
|
|
ppd_attr_t *ppd_attr; /* PPD attribute */
|
|
|
int xdpi, /* Horizontal resolution */
|
|
|
ydpi; /* Vertical resolution */
|
|
|
const char *resptr; /* Pointer into resolution keyword */
|
|
|
pwg_size_t *pwgsize; /* Current PWG size */
|
|
|
pwg_map_t *pwgsource, /* Current PWG source */
|
|
|
*pwgtype; /* Current PWG type */
|
|
|
ipp_attribute_t *attr; /* Attribute data */
|
|
|
_ipp_value_t *val; /* Attribute value */
|
|
|
int num_finishings, /* Number of finishings */
|
|
|
finishings[100]; /* finishings-supported values */
|
|
|
int num_qualities, /* Number of print-quality values */
|
|
|
qualities[3]; /* print-quality values */
|
|
|
int num_margins, /* Number of media-*-margin-supported values */
|
|
|
margins[16]; /* media-*-margin-supported values */
|
|
|
const char *filter, /* Current filter */
|
|
|
*mandatory; /* Current mandatory attribute */
|
|
|
static const char * const pwg_raster_document_types[] =
|
|
|
{
|
|
|
"black_1",
|
|
|
"sgray_8",
|
|
|
"srgb_8"
|
|
|
};
|
|
|
static const char * const sides[3] = /* sides-supported values */
|
|
|
{
|
|
|
"one-sided",
|
|
|
"two-sided-long-edge",
|
|
|
"two-sided-short-edge"
|
|
|
};
|
|
|
static const char * const standard_commands[] =
|
|
|
{ /* Standard CUPS commands */
|
|
|
"AutoConfigure",
|
|
|
"Clean",
|
|
|
"PrintSelfTestPage"
|
|
|
};
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Check to see if the cache is up-to-date...
|
|
|
*/
|
|
|
|
|
|
snprintf(cache_name, sizeof(cache_name), "%s/%s.data", CacheDir, p->name);
|
|
|
if (stat(cache_name, &cache_info))
|
|
|
cache_info.st_mtime = 0;
|
|
|
|
|
|
snprintf(ppd_name, sizeof(ppd_name), "%s/ppd/%s.ppd", ServerRoot, p->name);
|
|
|
if (stat(ppd_name, &ppd_info))
|
|
|
ppd_info.st_mtime = 1;
|
|
|
|
|
|
snprintf(strings_name, sizeof(strings_name), "%s/%s.strings", CacheDir, p->name);
|
|
|
|
|
|
ippDelete(p->ppd_attrs);
|
|
|
p->ppd_attrs = NULL;
|
|
|
|
|
|
_ppdCacheDestroy(p->pc);
|
|
|
p->pc = NULL;
|
|
|
|
|
|
if (cache_info.st_mtime >= ppd_info.st_mtime)
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG, "load_ppd: Loading %s...", cache_name);
|
|
|
|
|
|
if ((p->pc = _ppdCacheCreateWithFile(cache_name, &p->ppd_attrs)) != NULL &&
|
|
|
p->ppd_attrs)
|
|
|
{
|
|
|
/*
|
|
|
* Loaded successfully!
|
|
|
*/
|
|
|
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Reload PPD attributes from disk...
|
|
|
*/
|
|
|
|
|
|
cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG, "load_ppd: Loading %s...", ppd_name);
|
|
|
|
|
|
cupsdClearString(&(p->make_model));
|
|
|
|
|
|
p->type &= (cups_ptype_t)~CUPS_PRINTER_OPTIONS;
|
|
|
p->type |= CUPS_PRINTER_BW;
|
|
|
|
|
|
finishings[0] = IPP_FINISHINGS_NONE;
|
|
|
num_finishings = 1;
|
|
|
|
|
|
p->ppd_attrs = ippNew();
|
|
|
|
|
|
if ((ppd = _ppdOpenFile(ppd_name, _PPD_LOCALIZATION_NONE)) != NULL)
|
|
|
{
|
|
|
/*
|
|
|
* Add make/model and other various attributes...
|
|
|
*/
|
|
|
|
|
|
p->pc = _ppdCacheCreateWithPPD(ppd);
|
|
|
|
|
|
if (!p->pc)
|
|
|
cupsdLogMessage(CUPSD_LOG_WARN, "Unable to create cache of \"%s\": %s",
|
|
|
ppd_name, cupsLastErrorString());
|
|
|
|
|
|
ppdMarkDefaults(ppd);
|
|
|
|
|
|
if (ppd->color_device)
|
|
|
p->type |= CUPS_PRINTER_COLOR;
|
|
|
if (ppd->variable_sizes)
|
|
|
p->type |= CUPS_PRINTER_VARIABLE;
|
|
|
if (!ppd->manual_copies)
|
|
|
p->type |= CUPS_PRINTER_COPIES;
|
|
|
if ((ppd_attr = ppdFindAttr(ppd, "cupsFax", NULL)) != NULL)
|
|
|
if (ppd_attr->value && !_cups_strcasecmp(ppd_attr->value, "true"))
|
|
|
p->type |= CUPS_PRINTER_FAX;
|
|
|
|
|
|
ippAddBoolean(p->ppd_attrs, IPP_TAG_PRINTER, "color-supported", (char)ppd->color_device);
|
|
|
|
|
|
if (p->pc && p->pc->charge_info_uri)
|
|
|
ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_URI,
|
|
|
"printer-charge-info-uri", NULL, p->pc->charge_info_uri);
|
|
|
|
|
|
if (p->pc && p->pc->account_id)
|
|
|
ippAddBoolean(p->ppd_attrs, IPP_TAG_PRINTER, "job-account-id-supported",
|
|
|
1);
|
|
|
|
|
|
if (p->pc && p->pc->accounting_user_id)
|
|
|
ippAddBoolean(p->ppd_attrs, IPP_TAG_PRINTER,
|
|
|
"job-accounting-user-id-supported", 1);
|
|
|
|
|
|
if (p->pc && p->pc->password)
|
|
|
{
|
|
|
ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"job-password-encryption-supported", NULL, "none");
|
|
|
ippAddInteger(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
|
|
|
"job-password-supported", (int)strlen(p->pc->password));
|
|
|
}
|
|
|
|
|
|
if (ppd->throughput)
|
|
|
{
|
|
|
ippAddInteger(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
|
|
|
"pages-per-minute", ppd->throughput);
|
|
|
if (ppd->color_device)
|
|
|
ippAddInteger(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
|
|
|
"pages-per-minute-color", ppd->throughput);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
/*
|
|
|
* When there is no speed information, just say "1 page per minute".
|
|
|
*/
|
|
|
|
|
|
ippAddInteger(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
|
|
|
"pages-per-minute", 1);
|
|
|
if (ppd->color_device)
|
|
|
ippAddInteger(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
|
|
|
"pages-per-minute-color", 1);
|
|
|
}
|
|
|
|
|
|
if ((ppd_attr = ppdFindAttr(ppd, "1284DeviceId", NULL)) != NULL)
|
|
|
ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_TEXT, "printer-device-id", NULL, ppd_attr->value);
|
|
|
|
|
|
num_qualities = 0;
|
|
|
|
|
|
if ((output_mode = ppdFindOption(ppd, "OutputMode")) != NULL)
|
|
|
{
|
|
|
if (ppdFindChoice(output_mode, "draft") ||
|
|
|
ppdFindChoice(output_mode, "fast"))
|
|
|
qualities[num_qualities ++] = IPP_QUALITY_DRAFT;
|
|
|
|
|
|
qualities[num_qualities ++] = IPP_QUALITY_NORMAL;
|
|
|
|
|
|
if (ppdFindChoice(output_mode, "best") ||
|
|
|
ppdFindChoice(output_mode, "high"))
|
|
|
qualities[num_qualities ++] = IPP_QUALITY_HIGH;
|
|
|
}
|
|
|
else if ((ppd_attr = ppdFindAttr(ppd, "APPrinterPreset", NULL)) != NULL)
|
|
|
{
|
|
|
do
|
|
|
{
|
|
|
if (strstr(ppd_attr->spec, "draft") ||
|
|
|
strstr(ppd_attr->spec, "Draft"))
|
|
|
{
|
|
|
qualities[num_qualities ++] = IPP_QUALITY_DRAFT;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
while ((ppd_attr = ppdFindNextAttr(ppd, "APPrinterPreset",
|
|
|
NULL)) != NULL);
|
|
|
|
|
|
qualities[num_qualities ++] = IPP_QUALITY_NORMAL;
|
|
|
qualities[num_qualities ++] = IPP_QUALITY_HIGH;
|
|
|
}
|
|
|
else
|
|
|
qualities[num_qualities ++] = IPP_QUALITY_NORMAL;
|
|
|
|
|
|
ippAddIntegers(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_ENUM,
|
|
|
"print-quality-supported", num_qualities, qualities);
|
|
|
|
|
|
if (ppd->nickname)
|
|
|
{
|
|
|
/*
|
|
|
* The NickName can be localized in the character set specified
|
|
|
* by the LanugageEncoding attribute. However, ppdOpen2() has
|
|
|
* already converted the ppd->nickname member to UTF-8 for us
|
|
|
* (the original attribute value is available separately)
|
|
|
*/
|
|
|
|
|
|
cupsdSetString(&p->make_model, ppd->nickname);
|
|
|
}
|
|
|
else if (ppd->modelname)
|
|
|
{
|
|
|
/*
|
|
|
* Model name can only contain specific characters...
|
|
|
*/
|
|
|
|
|
|
cupsdSetString(&p->make_model, ppd->modelname);
|
|
|
}
|
|
|
else
|
|
|
cupsdSetString(&p->make_model, "Bad PPD File");
|
|
|
|
|
|
ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_TEXT,
|
|
|
"printer-make-and-model", NULL, p->make_model);
|
|
|
|
|
|
if (p->pc && p->pc->strings)
|
|
|
_cupsMessageSave(strings_name, _CUPS_MESSAGE_STRINGS, p->pc->strings);
|
|
|
|
|
|
if (!access(strings_name, R_OK))
|
|
|
cupsdSetString(&p->strings, strings_name);
|
|
|
else
|
|
|
cupsdClearString(&p->strings);
|
|
|
|
|
|
/*
|
|
|
* Add media options from the PPD file...
|
|
|
*/
|
|
|
|
|
|
if (ppd->num_sizes == 0 || !p->pc)
|
|
|
{
|
|
|
if (!ppdFindAttr(ppd, "APScannerOnly", NULL) && !ppdFindAttr(ppd, "cups3D", NULL))
|
|
|
cupsdLogMessage(CUPSD_LOG_CRIT,
|
|
|
"The PPD file for printer %s contains no media "
|
|
|
"options and is therefore invalid.", p->name);
|
|
|
|
|
|
ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"media-default", NULL, "unknown");
|
|
|
ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"media-supported", NULL, "unknown");
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
/*
|
|
|
* media-default
|
|
|
*/
|
|
|
|
|
|
if ((size = ppdPageSize(ppd, NULL)) != NULL)
|
|
|
pwgsize = _ppdCacheGetSize(p->pc, size->name);
|
|
|
else
|
|
|
pwgsize = NULL;
|
|
|
|
|
|
ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"media-default", NULL,
|
|
|
pwgsize ? pwgsize->map.pwg : "unknown");
|
|
|
|
|
|
/*
|
|
|
* media-col-default
|
|
|
*/
|
|
|
|
|
|
if (pwgsize)
|
|
|
{
|
|
|
ipp_t *col; /* Collection value */
|
|
|
|
|
|
col = new_media_col(pwgsize);
|
|
|
ippAddCollection(p->ppd_attrs, IPP_TAG_PRINTER, "media-col-default", col);
|
|
|
ippDelete(col);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* media-supported
|
|
|
*/
|
|
|
|
|
|
num_media = p->pc->num_sizes;
|
|
|
if (p->pc->custom_min_keyword)
|
|
|
num_media += 2;
|
|
|
|
|
|
if ((attr = ippAddStrings(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"media-supported", num_media, NULL,
|
|
|
NULL)) != NULL)
|
|
|
{
|
|
|
val = attr->values;
|
|
|
|
|
|
for (i = p->pc->num_sizes, pwgsize = p->pc->sizes;
|
|
|
i > 0;
|
|
|
i --, pwgsize ++, val ++)
|
|
|
val->string.text = _cupsStrAlloc(pwgsize->map.pwg);
|
|
|
|
|
|
if (p->pc->custom_min_keyword)
|
|
|
{
|
|
|
val->string.text = _cupsStrAlloc(p->pc->custom_min_keyword);
|
|
|
val ++;
|
|
|
val->string.text = _cupsStrAlloc(p->pc->custom_max_keyword);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* media-size-supported
|
|
|
*/
|
|
|
|
|
|
num_media = p->pc->num_sizes;
|
|
|
if (p->pc->custom_min_keyword)
|
|
|
num_media ++;
|
|
|
|
|
|
if ((attr = ippAddCollections(p->ppd_attrs, IPP_TAG_PRINTER,
|
|
|
"media-size-supported", num_media,
|
|
|
NULL)) != NULL)
|
|
|
{
|
|
|
val = attr->values;
|
|
|
|
|
|
for (i = p->pc->num_sizes, pwgsize = p->pc->sizes;
|
|
|
i > 0;
|
|
|
i --, pwgsize ++, val ++)
|
|
|
{
|
|
|
val->collection = ippNew();
|
|
|
ippAddInteger(val->collection, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
|
|
|
"x-dimension", pwgsize->width);
|
|
|
ippAddInteger(val->collection, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
|
|
|
"y-dimension", pwgsize->length);
|
|
|
}
|
|
|
|
|
|
if (p->pc->custom_min_keyword)
|
|
|
{
|
|
|
val->collection = ippNew();
|
|
|
ippAddRange(val->collection, IPP_TAG_PRINTER, "x-dimension",
|
|
|
p->pc->custom_min_width, p->pc->custom_max_width);
|
|
|
ippAddRange(val->collection, IPP_TAG_PRINTER, "y-dimension",
|
|
|
p->pc->custom_min_length, p->pc->custom_max_length);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* media-source-supported
|
|
|
*/
|
|
|
|
|
|
if (p->pc->num_sources > 0 &&
|
|
|
(attr = ippAddStrings(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"media-source-supported", p->pc->num_sources,
|
|
|
NULL, NULL)) != NULL)
|
|
|
{
|
|
|
for (i = p->pc->num_sources, pwgsource = p->pc->sources,
|
|
|
val = attr->values;
|
|
|
i > 0;
|
|
|
i --, pwgsource ++, val ++)
|
|
|
val->string.text = _cupsStrAlloc(pwgsource->pwg);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* media-type-supported
|
|
|
*/
|
|
|
|
|
|
if (p->pc->num_types > 0 &&
|
|
|
(attr = ippAddStrings(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"media-type-supported", p->pc->num_types,
|
|
|
NULL, NULL)) != NULL)
|
|
|
{
|
|
|
for (i = p->pc->num_types, pwgtype = p->pc->types,
|
|
|
val = attr->values;
|
|
|
i > 0;
|
|
|
i --, pwgtype ++, val ++)
|
|
|
val->string.text = _cupsStrAlloc(pwgtype->pwg);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* media-*-margin-supported
|
|
|
*/
|
|
|
|
|
|
for (i = p->pc->num_sizes, pwgsize = p->pc->sizes, num_margins = 0;
|
|
|
i > 0 && num_margins < (int)(sizeof(margins) / sizeof(margins[0]));
|
|
|
i --, pwgsize ++)
|
|
|
{
|
|
|
for (j = 0; j < num_margins; j ++)
|
|
|
if (pwgsize->bottom == margins[j])
|
|
|
break;
|
|
|
|
|
|
if (j >= num_margins)
|
|
|
{
|
|
|
margins[num_margins] = pwgsize->bottom;
|
|
|
num_margins ++;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (num_margins > 0)
|
|
|
ippAddIntegers(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
|
|
|
"media-bottom-margin-supported", num_margins, margins);
|
|
|
else
|
|
|
ippAddInteger(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
|
|
|
"media-bottom-margin-supported", 0);
|
|
|
|
|
|
for (i = p->pc->num_sizes, pwgsize = p->pc->sizes, num_margins = 0;
|
|
|
i > 0 && num_margins < (int)(sizeof(margins) / sizeof(margins[0]));
|
|
|
i --, pwgsize ++)
|
|
|
{
|
|
|
for (j = 0; j < num_margins; j ++)
|
|
|
if (pwgsize->left == margins[j])
|
|
|
break;
|
|
|
|
|
|
if (j >= num_margins)
|
|
|
{
|
|
|
margins[num_margins] = pwgsize->left;
|
|
|
num_margins ++;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (num_margins > 0)
|
|
|
ippAddIntegers(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
|
|
|
"media-left-margin-supported", num_margins, margins);
|
|
|
else
|
|
|
ippAddInteger(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
|
|
|
"media-left-margin-supported", 0);
|
|
|
|
|
|
for (i = p->pc->num_sizes, pwgsize = p->pc->sizes, num_margins = 0;
|
|
|
i > 0 && num_margins < (int)(sizeof(margins) / sizeof(margins[0]));
|
|
|
i --, pwgsize ++)
|
|
|
{
|
|
|
for (j = 0; j < num_margins; j ++)
|
|
|
if (pwgsize->right == margins[j])
|
|
|
break;
|
|
|
|
|
|
if (j >= num_margins)
|
|
|
{
|
|
|
margins[num_margins] = pwgsize->right;
|
|
|
num_margins ++;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (num_margins > 0)
|
|
|
ippAddIntegers(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
|
|
|
"media-right-margin-supported", num_margins, margins);
|
|
|
else
|
|
|
ippAddInteger(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
|
|
|
"media-right-margin-supported", 0);
|
|
|
|
|
|
for (i = p->pc->num_sizes, pwgsize = p->pc->sizes, num_margins = 0;
|
|
|
i > 0 && num_margins < (int)(sizeof(margins) / sizeof(margins[0]));
|
|
|
i --, pwgsize ++)
|
|
|
{
|
|
|
for (j = 0; j < num_margins; j ++)
|
|
|
if (pwgsize->top == margins[j])
|
|
|
break;
|
|
|
|
|
|
if (j >= num_margins)
|
|
|
{
|
|
|
margins[num_margins] = pwgsize->top;
|
|
|
num_margins ++;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (num_margins > 0)
|
|
|
ippAddIntegers(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
|
|
|
"media-top-margin-supported", num_margins, margins);
|
|
|
else
|
|
|
ippAddInteger(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
|
|
|
"media-top-margin-supported", 0);
|
|
|
|
|
|
/*
|
|
|
* media-col-database
|
|
|
*/
|
|
|
|
|
|
if ((attr = ippAddCollections(p->ppd_attrs, IPP_TAG_PRINTER, "media-col-database", p->pc->num_sizes, NULL)) != NULL)
|
|
|
{
|
|
|
/*
|
|
|
* Add each page size without source or type...
|
|
|
*/
|
|
|
|
|
|
for (i = 0, pwgsize = p->pc->sizes; i < p->pc->num_sizes; i ++, pwgsize ++)
|
|
|
{
|
|
|
ipp_t *col = new_media_col(pwgsize);
|
|
|
|
|
|
ippSetCollection(p->ppd_attrs, &attr, i, col);
|
|
|
ippDelete(col);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Output bin...
|
|
|
*/
|
|
|
|
|
|
if (p->pc && p->pc->num_bins > 0)
|
|
|
{
|
|
|
attr = ippAddStrings(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"output-bin-supported", p->pc->num_bins,
|
|
|
NULL, NULL);
|
|
|
|
|
|
if (attr != NULL)
|
|
|
{
|
|
|
for (i = 0, val = attr->values;
|
|
|
i < p->pc->num_bins;
|
|
|
i ++, val ++)
|
|
|
val->string.text = _cupsStrAlloc(p->pc->bins[i].pwg);
|
|
|
}
|
|
|
|
|
|
if ((output_bin = ppdFindOption(ppd, "OutputBin")) != NULL)
|
|
|
{
|
|
|
for (i = 0; i < p->pc->num_bins; i ++)
|
|
|
if (!strcmp(p->pc->bins[i].ppd, output_bin->defchoice))
|
|
|
break;
|
|
|
|
|
|
if (i >= p->pc->num_bins)
|
|
|
i = 0;
|
|
|
|
|
|
ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"output-bin-default", NULL, p->pc->bins[i].pwg);
|
|
|
}
|
|
|
else
|
|
|
ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"output-bin-default", NULL, p->pc->bins[0].pwg);
|
|
|
}
|
|
|
else if (((ppd_attr = ppdFindAttr(ppd, "DefaultOutputOrder",
|
|
|
NULL)) != NULL &&
|
|
|
!_cups_strcasecmp(ppd_attr->value, "Reverse")) ||
|
|
|
(!ppd_attr && ppd->manufacturer && /* "Compatibility heuristic" */
|
|
|
(!_cups_strcasecmp(ppd->manufacturer, "epson") ||
|
|
|
!_cups_strcasecmp(ppd->manufacturer, "lexmark"))))
|
|
|
{
|
|
|
/*
|
|
|
* Report that this printer has a single output bin that leaves pages face
|
|
|
* up.
|
|
|
*/
|
|
|
|
|
|
ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"output-bin-supported", NULL, "face-up");
|
|
|
ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"output-bin-default", NULL, "face-up");
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"output-bin-supported", NULL, "face-down");
|
|
|
ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"output-bin-default", NULL, "face-down");
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* print-color-mode...
|
|
|
*/
|
|
|
|
|
|
if (ppd->color_device)
|
|
|
{
|
|
|
static const char * const color_modes[] =
|
|
|
{
|
|
|
"monochrome",
|
|
|
"color"
|
|
|
};
|
|
|
|
|
|
ippAddStrings(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"print-color-mode-supported", 2, NULL, color_modes);
|
|
|
ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"print-color-mode-default", NULL, "color");
|
|
|
ippAddStrings(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD, "pwg-raster-document-type-supported", 3, NULL, pwg_raster_document_types);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"print-color-mode-supported", NULL, "monochrome");
|
|
|
ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"print-color-mode-default", NULL, "monochrome");
|
|
|
ippAddStrings(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD, "pwg-raster-document-type-supported", 2, NULL, pwg_raster_document_types);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Mandatory job attributes, if any...
|
|
|
*/
|
|
|
|
|
|
if (p->pc && cupsArrayCount(p->pc->mandatory) > 0)
|
|
|
{
|
|
|
int count = cupsArrayCount(p->pc->mandatory);
|
|
|
/* Number of mandatory attributes */
|
|
|
|
|
|
attr = ippAddStrings(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"printer-mandatory-job-attributes", count, NULL,
|
|
|
NULL);
|
|
|
|
|
|
for (val = attr->values,
|
|
|
mandatory = (char *)cupsArrayFirst(p->pc->mandatory);
|
|
|
mandatory;
|
|
|
val ++, mandatory = (char *)cupsArrayNext(p->pc->mandatory))
|
|
|
val->string.text = _cupsStrAlloc(mandatory);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Printer resolutions...
|
|
|
*/
|
|
|
|
|
|
if ((resolution = ppdFindOption(ppd, "Resolution")) == NULL)
|
|
|
if ((resolution = ppdFindOption(ppd, "JCLResolution")) == NULL)
|
|
|
if ((resolution = ppdFindOption(ppd, "SetResolution")) == NULL)
|
|
|
resolution = ppdFindOption(ppd, "CNRes_PGP");
|
|
|
|
|
|
if (resolution)
|
|
|
{
|
|
|
/*
|
|
|
* Report all supported resolutions...
|
|
|
*/
|
|
|
|
|
|
attr = ippAddResolutions(p->ppd_attrs, IPP_TAG_PRINTER, "printer-resolution-supported", resolution->num_choices, IPP_RES_PER_INCH, NULL, NULL);
|
|
|
|
|
|
for (i = 0, choice = resolution->choices;
|
|
|
i < resolution->num_choices;
|
|
|
i ++, choice ++)
|
|
|
{
|
|
|
xdpi = ydpi = (int)strtol(choice->choice, (char **)&resptr, 10);
|
|
|
if (resptr > choice->choice && xdpi > 0 && *resptr == 'x')
|
|
|
ydpi = (int)strtol(resptr + 1, (char **)&resptr, 10);
|
|
|
|
|
|
if (xdpi <= 0 || ydpi <= 0)
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_WARN,
|
|
|
"Bad resolution \"%s\" for printer %s.",
|
|
|
choice->choice, p->name);
|
|
|
xdpi = ydpi = 300;
|
|
|
}
|
|
|
|
|
|
attr->values[i].resolution.xres = xdpi;
|
|
|
attr->values[i].resolution.yres = ydpi;
|
|
|
attr->values[i].resolution.units = IPP_RES_PER_INCH;
|
|
|
|
|
|
if (choice->marked)
|
|
|
ippAddResolution(p->ppd_attrs, IPP_TAG_PRINTER, "printer-resolution-default", IPP_RES_PER_INCH, xdpi, ydpi);
|
|
|
|
|
|
if (i == 0)
|
|
|
ippAddResolution(p->ppd_attrs, IPP_TAG_PRINTER, "pwg-raster-document-resolution-supported", IPP_RES_PER_INCH, xdpi, ydpi);
|
|
|
}
|
|
|
}
|
|
|
else if ((ppd_attr = ppdFindAttr(ppd, "DefaultResolution", NULL)) != NULL &&
|
|
|
ppd_attr->value)
|
|
|
{
|
|
|
/*
|
|
|
* Just the DefaultResolution to report...
|
|
|
*/
|
|
|
|
|
|
xdpi = ydpi = (int)strtol(ppd_attr->value, (char **)&resptr, 10);
|
|
|
if (resptr > ppd_attr->value && xdpi > 0)
|
|
|
{
|
|
|
if (*resptr == 'x')
|
|
|
ydpi = (int)strtol(resptr + 1, (char **)&resptr, 10);
|
|
|
else
|
|
|
ydpi = xdpi;
|
|
|
}
|
|
|
|
|
|
if (xdpi <= 0 || ydpi <= 0)
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_WARN,
|
|
|
"Bad default resolution \"%s\" for printer %s.",
|
|
|
ppd_attr->value, p->name);
|
|
|
xdpi = ydpi = 300;
|
|
|
}
|
|
|
|
|
|
ippAddResolution(p->ppd_attrs, IPP_TAG_PRINTER,
|
|
|
"printer-resolution-default", IPP_RES_PER_INCH,
|
|
|
xdpi, ydpi);
|
|
|
ippAddResolution(p->ppd_attrs, IPP_TAG_PRINTER,
|
|
|
"printer-resolution-supported", IPP_RES_PER_INCH,
|
|
|
xdpi, ydpi);
|
|
|
ippAddResolution(p->ppd_attrs, IPP_TAG_PRINTER, "pwg-raster-document-resolution-supported", IPP_RES_PER_INCH, xdpi, ydpi);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
/*
|
|
|
* No resolutions in PPD - make one up...
|
|
|
*/
|
|
|
|
|
|
ippAddResolution(p->ppd_attrs, IPP_TAG_PRINTER,
|
|
|
"printer-resolution-default", IPP_RES_PER_INCH,
|
|
|
300, 300);
|
|
|
ippAddResolution(p->ppd_attrs, IPP_TAG_PRINTER,
|
|
|
"printer-resolution-supported", IPP_RES_PER_INCH,
|
|
|
300, 300);
|
|
|
ippAddResolution(p->ppd_attrs, IPP_TAG_PRINTER, "pwg-raster-document-resolution-supported", IPP_RES_PER_INCH, 300, 300);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Duplexing, etc...
|
|
|
*/
|
|
|
|
|
|
ppdMarkDefaults(ppd);
|
|
|
|
|
|
if ((duplex = ppdFindOption(ppd, "Duplex")) == NULL)
|
|
|
if ((duplex = ppdFindOption(ppd, "EFDuplex")) == NULL)
|
|
|
if ((duplex = ppdFindOption(ppd, "EFDuplexing")) == NULL)
|
|
|
if ((duplex = ppdFindOption(ppd, "KD03Duplex")) == NULL)
|
|
|
duplex = ppdFindOption(ppd, "JCLDuplex");
|
|
|
|
|
|
if (duplex && duplex->num_choices > 1 &&
|
|
|
!ppdInstallableConflict(ppd, duplex->keyword, "DuplexTumble"))
|
|
|
{
|
|
|
p->type |= CUPS_PRINTER_DUPLEX;
|
|
|
|
|
|
ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD, "pwg-raster-document-sheet-back", NULL, "normal");
|
|
|
|
|
|
ippAddStrings(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"sides-supported", 3, NULL, sides);
|
|
|
|
|
|
if (!_cups_strcasecmp(duplex->defchoice, "DuplexTumble"))
|
|
|
ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"sides-default", NULL, "two-sided-short-edge");
|
|
|
else if (!_cups_strcasecmp(duplex->defchoice, "DuplexNoTumble"))
|
|
|
ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"sides-default", NULL, "two-sided-long-edge");
|
|
|
else
|
|
|
ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"sides-default", NULL, "one-sided");
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"sides-supported", NULL, "one-sided");
|
|
|
ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"sides-default", NULL, "one-sided");
|
|
|
}
|
|
|
|
|
|
if (ppdFindOption(ppd, "Collate") != NULL)
|
|
|
p->type |= CUPS_PRINTER_COLLATE;
|
|
|
|
|
|
if (p->pc && p->pc->finishings)
|
|
|
{
|
|
|
_pwg_finishings_t *fin; /* Current finishing value */
|
|
|
|
|
|
for (fin = (_pwg_finishings_t *)cupsArrayFirst(p->pc->finishings); fin; fin = (_pwg_finishings_t *)cupsArrayNext(p->pc->finishings))
|
|
|
{
|
|
|
if (num_finishings < (int)(sizeof(finishings) / sizeof(finishings[0])))
|
|
|
finishings[num_finishings++] = (int)fin->value;
|
|
|
|
|
|
switch (fin->value)
|
|
|
{
|
|
|
case IPP_FINISHINGS_BIND :
|
|
|
case IPP_FINISHINGS_BIND_LEFT :
|
|
|
case IPP_FINISHINGS_BIND_TOP :
|
|
|
case IPP_FINISHINGS_BIND_RIGHT :
|
|
|
case IPP_FINISHINGS_BIND_BOTTOM :
|
|
|
case IPP_FINISHINGS_EDGE_STITCH :
|
|
|
case IPP_FINISHINGS_EDGE_STITCH_LEFT :
|
|
|
case IPP_FINISHINGS_EDGE_STITCH_TOP :
|
|
|
case IPP_FINISHINGS_EDGE_STITCH_RIGHT :
|
|
|
case IPP_FINISHINGS_EDGE_STITCH_BOTTOM :
|
|
|
p->type |= CUPS_PRINTER_BIND;
|
|
|
break;
|
|
|
|
|
|
case IPP_FINISHINGS_COVER :
|
|
|
p->type |= CUPS_PRINTER_COVER;
|
|
|
break;
|
|
|
|
|
|
case IPP_FINISHINGS_PUNCH :
|
|
|
case IPP_FINISHINGS_PUNCH_TOP_LEFT :
|
|
|
case IPP_FINISHINGS_PUNCH_BOTTOM_LEFT :
|
|
|
case IPP_FINISHINGS_PUNCH_TOP_RIGHT :
|
|
|
case IPP_FINISHINGS_PUNCH_BOTTOM_RIGHT :
|
|
|
case IPP_FINISHINGS_PUNCH_DUAL_LEFT :
|
|
|
case IPP_FINISHINGS_PUNCH_DUAL_TOP :
|
|
|
case IPP_FINISHINGS_PUNCH_DUAL_RIGHT :
|
|
|
case IPP_FINISHINGS_PUNCH_DUAL_BOTTOM :
|
|
|
case IPP_FINISHINGS_PUNCH_TRIPLE_LEFT :
|
|
|
case IPP_FINISHINGS_PUNCH_TRIPLE_TOP :
|
|
|
case IPP_FINISHINGS_PUNCH_TRIPLE_RIGHT :
|
|
|
case IPP_FINISHINGS_PUNCH_TRIPLE_BOTTOM :
|
|
|
case IPP_FINISHINGS_PUNCH_QUAD_LEFT :
|
|
|
case IPP_FINISHINGS_PUNCH_QUAD_TOP :
|
|
|
case IPP_FINISHINGS_PUNCH_QUAD_RIGHT :
|
|
|
case IPP_FINISHINGS_PUNCH_QUAD_BOTTOM :
|
|
|
p->type |= CUPS_PRINTER_PUNCH;
|
|
|
break;
|
|
|
|
|
|
case IPP_FINISHINGS_STAPLE :
|
|
|
case IPP_FINISHINGS_STAPLE_TOP_LEFT :
|
|
|
case IPP_FINISHINGS_STAPLE_BOTTOM_LEFT :
|
|
|
case IPP_FINISHINGS_STAPLE_TOP_RIGHT :
|
|
|
case IPP_FINISHINGS_STAPLE_BOTTOM_RIGHT :
|
|
|
case IPP_FINISHINGS_STAPLE_DUAL_LEFT :
|
|
|
case IPP_FINISHINGS_STAPLE_DUAL_TOP :
|
|
|
case IPP_FINISHINGS_STAPLE_DUAL_RIGHT :
|
|
|
case IPP_FINISHINGS_STAPLE_DUAL_BOTTOM :
|
|
|
case IPP_FINISHINGS_STAPLE_TRIPLE_LEFT :
|
|
|
case IPP_FINISHINGS_STAPLE_TRIPLE_TOP :
|
|
|
case IPP_FINISHINGS_STAPLE_TRIPLE_RIGHT :
|
|
|
case IPP_FINISHINGS_STAPLE_TRIPLE_BOTTOM :
|
|
|
p->type |= CUPS_PRINTER_STAPLE;
|
|
|
break;
|
|
|
|
|
|
default :
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (p->pc && p->pc->templates)
|
|
|
{
|
|
|
const char *template; /* Finishing template */
|
|
|
ipp_attribute_t *fin_col_db; /* finishings-col-database attribute */
|
|
|
ipp_t *fin_col; /* finishings-col value */
|
|
|
|
|
|
fin_col_db = ippAddCollections(p->ppd_attrs, IPP_TAG_PRINTER, "finishings-col-database", cupsArrayCount(p->pc->templates), NULL);
|
|
|
for (i = 0, template = (const char *)cupsArrayFirst(p->pc->templates); template; i ++, template = (const char *)cupsArrayNext(p->pc->templates))
|
|
|
{
|
|
|
fin_col = ippNew();
|
|
|
ippAddString(fin_col, IPP_TAG_PRINTER, IPP_TAG_KEYWORD, "finishing-template", NULL, template);
|
|
|
ippSetCollection(p->ppd_attrs, &fin_col_db, i, fin_col);
|
|
|
ippDelete(fin_col);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
for (i = 0; i < ppd->num_sizes; i ++)
|
|
|
if (ppd->sizes[i].length > 1728)
|
|
|
p->type |= CUPS_PRINTER_LARGE;
|
|
|
else if (ppd->sizes[i].length > 1008)
|
|
|
p->type |= CUPS_PRINTER_MEDIUM;
|
|
|
else
|
|
|
p->type |= CUPS_PRINTER_SMALL;
|
|
|
|
|
|
if ((ppd_attr = ppdFindAttr(ppd, "APICADriver", NULL)) != NULL &&
|
|
|
ppd_attr->value && !_cups_strcasecmp(ppd_attr->value, "true"))
|
|
|
{
|
|
|
if ((ppd_attr = ppdFindAttr(ppd, "APScannerOnly", NULL)) != NULL &&
|
|
|
ppd_attr->value && !_cups_strcasecmp(ppd_attr->value, "true"))
|
|
|
p->type |= CUPS_PRINTER_SCANNER;
|
|
|
else
|
|
|
p->type |= CUPS_PRINTER_MFP;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Scan the filters in the PPD file...
|
|
|
*/
|
|
|
|
|
|
if (p->pc)
|
|
|
{
|
|
|
for (filter = (const char *)cupsArrayFirst(p->pc->filters);
|
|
|
filter;
|
|
|
filter = (const char *)cupsArrayNext(p->pc->filters))
|
|
|
{
|
|
|
if (!_cups_strncasecmp(filter, "application/vnd.cups-command", 28) &&
|
|
|
_cups_isspace(filter[28]))
|
|
|
{
|
|
|
p->type |= CUPS_PRINTER_COMMANDS;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (p->type & CUPS_PRINTER_COMMANDS)
|
|
|
{
|
|
|
char *commands, /* Copy of commands */
|
|
|
*start, /* Start of name */
|
|
|
*end; /* End of name */
|
|
|
int count; /* Number of commands */
|
|
|
|
|
|
if ((ppd_attr = ppdFindAttr(ppd, "cupsCommands", NULL)) != NULL)
|
|
|
{
|
|
|
for (count = 0, start = ppd_attr->value; *start; count ++)
|
|
|
{
|
|
|
while (_cups_isspace(*start))
|
|
|
start ++;
|
|
|
|
|
|
if (!*start)
|
|
|
break;
|
|
|
|
|
|
while (*start && !isspace(*start & 255))
|
|
|
start ++;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
count = 0;
|
|
|
|
|
|
if (count > 0)
|
|
|
{
|
|
|
/*
|
|
|
* Make a copy of the commands string and count how many commands there
|
|
|
* are...
|
|
|
*/
|
|
|
|
|
|
attr = ippAddStrings(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"printer-commands", count, NULL, NULL);
|
|
|
|
|
|
commands = strdup(ppd_attr->value);
|
|
|
|
|
|
for (count = 0, start = commands; *start; count ++)
|
|
|
{
|
|
|
while (isspace(*start & 255))
|
|
|
start ++;
|
|
|
|
|
|
if (!*start)
|
|
|
break;
|
|
|
|
|
|
end = start;
|
|
|
while (*end && !isspace(*end & 255))
|
|
|
end ++;
|
|
|
|
|
|
if (*end)
|
|
|
*end++ = '\0';
|
|
|
|
|
|
attr->values[count].string.text = _cupsStrAlloc(start);
|
|
|
|
|
|
start = end;
|
|
|
}
|
|
|
|
|
|
free(commands);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
/*
|
|
|
* Add the standard list of commands...
|
|
|
*/
|
|
|
|
|
|
ippAddStrings(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"printer-commands",
|
|
|
(int)(sizeof(standard_commands) /
|
|
|
sizeof(standard_commands[0])), NULL,
|
|
|
standard_commands);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
/*
|
|
|
* No commands supported...
|
|
|
*/
|
|
|
|
|
|
ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
|
|
|
"printer-commands", NULL, "none");
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Show current and available port monitors for this printer...
|
|
|
*/
|
|
|
|
|
|
ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_NAME, "port-monitor",
|
|
|
NULL, p->port_monitor ? p->port_monitor : "none");
|
|
|
|
|
|
for (i = 1, ppd_attr = ppdFindAttr(ppd, "cupsPortMonitor", NULL);
|
|
|
ppd_attr;
|
|
|
i ++, ppd_attr = ppdFindNextAttr(ppd, "cupsPortMonitor", NULL));
|
|
|
|
|
|
if (ppd->protocols)
|
|
|
{
|
|
|
if (strstr(ppd->protocols, "TBCP"))
|
|
|
i ++;
|
|
|
else if (strstr(ppd->protocols, "BCP"))
|
|
|
i ++;
|
|
|
}
|
|
|
|
|
|
attr = ippAddStrings(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_NAME,
|
|
|
"port-monitor-supported", i, NULL, NULL);
|
|
|
|
|
|
attr->values[0].string.text = _cupsStrAlloc("none");
|
|
|
|
|
|
for (i = 1, ppd_attr = ppdFindAttr(ppd, "cupsPortMonitor", NULL);
|
|
|
ppd_attr;
|
|
|
i ++, ppd_attr = ppdFindNextAttr(ppd, "cupsPortMonitor", NULL))
|
|
|
attr->values[i].string.text = _cupsStrAlloc(ppd_attr->value);
|
|
|
|
|
|
if (ppd->protocols)
|
|
|
{
|
|
|
if (strstr(ppd->protocols, "TBCP"))
|
|
|
attr->values[i].string.text = _cupsStrAlloc("tbcp");
|
|
|
else if (strstr(ppd->protocols, "BCP"))
|
|
|
attr->values[i].string.text = _cupsStrAlloc("bcp");
|
|
|
}
|
|
|
|
|
|
if (ppdFindAttr(ppd, "APRemoteQueueID", NULL))
|
|
|
p->type |= CUPS_PRINTER_REMOTE;
|
|
|
|
|
|
#ifdef HAVE_APPLICATIONSERVICES_H
|
|
|
/*
|
|
|
* Convert the file referenced in APPrinterIconPath to a 128x128 PNG
|
|
|
* and save it as cacheDir/printername.png
|
|
|
*/
|
|
|
|
|
|
if ((ppd_attr = ppdFindAttr(ppd, "APPrinterIconPath", NULL)) != NULL &&
|
|
|
ppd_attr->value &&
|
|
|
!_cupsFileCheck(ppd_attr->value, _CUPS_FILE_CHECK_FILE, !RunUser,
|
|
|
cupsdLogFCMessage, p))
|
|
|
{
|
|
|
CGImageRef imageRef = NULL;/* Current icon image */
|
|
|
CGImageRef biggestIconRef = NULL;
|
|
|
/* Biggest icon image */
|
|
|
CGImageRef closestTo128IconRef = NULL;
|
|
|
/* Icon image closest to and >= 128 */
|
|
|
CGImageSourceRef sourceRef; /* The file's image source */
|
|
|
char outPath[HTTP_MAX_URI];
|
|
|
/* The path to the PNG file */
|
|
|
CFURLRef outUrl; /* The URL made from the outPath */
|
|
|
CFURLRef icnsFileUrl; /* The URL of the original ICNS icon file */
|
|
|
CGImageDestinationRef destRef; /* The image destination to write */
|
|
|
size_t bytesPerRow; /* The bytes per row used for resizing */
|
|
|
CGContextRef context; /* The CG context used for resizing */
|
|
|
|
|
|
snprintf(outPath, sizeof(outPath), "%s/%s.png", CacheDir, p->name);
|
|
|
outUrl = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault, (UInt8 *)outPath, (CFIndex)strlen(outPath), FALSE);
|
|
|
icnsFileUrl = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault, (UInt8 *)ppd_attr->value, (CFIndex)strlen(ppd_attr->value), FALSE);
|
|
|
if (outUrl && icnsFileUrl)
|
|
|
{
|
|
|
sourceRef = CGImageSourceCreateWithURL(icnsFileUrl, NULL);
|
|
|
if (sourceRef)
|
|
|
{
|
|
|
for (i = 0; i < (int)CGImageSourceGetCount(sourceRef); i ++)
|
|
|
{
|
|
|
imageRef = CGImageSourceCreateImageAtIndex(sourceRef, (size_t)i, NULL);
|
|
|
if (!imageRef)
|
|
|
continue;
|
|
|
|
|
|
if (CGImageGetWidth(imageRef) == CGImageGetHeight(imageRef))
|
|
|
{
|
|
|
/*
|
|
|
* Loop through remembering the icon closest to 128 but >= 128
|
|
|
* and then remember the largest icon.
|
|
|
*/
|
|
|
|
|
|
if (CGImageGetWidth(imageRef) >= 128 &&
|
|
|
(!closestTo128IconRef ||
|
|
|
CGImageGetWidth(imageRef) <
|
|
|
CGImageGetWidth(closestTo128IconRef)))
|
|
|
{
|
|
|
CGImageRelease(closestTo128IconRef);
|
|
|
CGImageRetain(imageRef);
|
|
|
closestTo128IconRef = imageRef;
|
|
|
}
|
|
|
|
|
|
if (!biggestIconRef ||
|
|
|
CGImageGetWidth(imageRef) > CGImageGetWidth(biggestIconRef))
|
|
|
{
|
|
|
CGImageRelease(biggestIconRef);
|
|
|
CGImageRetain(imageRef);
|
|
|
biggestIconRef = imageRef;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
CGImageRelease(imageRef);
|
|
|
}
|
|
|
|
|
|
if (biggestIconRef)
|
|
|
{
|
|
|
/*
|
|
|
* If biggestIconRef is NULL, we found no icons. Otherwise we first
|
|
|
* want the closest to 128, but if none are larger than 128, we want
|
|
|
* the largest icon available.
|
|
|
*/
|
|
|
|
|
|
imageRef = closestTo128IconRef ? closestTo128IconRef :
|
|
|
biggestIconRef;
|
|
|
CGImageRetain(imageRef);
|
|
|
CGImageRelease(biggestIconRef);
|
|
|
if (closestTo128IconRef)
|
|
|
CGImageRelease(closestTo128IconRef);
|
|
|
destRef = CGImageDestinationCreateWithURL(outUrl, kUTTypePNG, 1,
|
|
|
NULL);
|
|
|
if (destRef)
|
|
|
{
|
|
|
if (CGImageGetWidth(imageRef) != 128)
|
|
|
{
|
|
|
bytesPerRow = CGImageGetBytesPerRow(imageRef) /
|
|
|
CGImageGetWidth(imageRef) * 128;
|
|
|
context = CGBitmapContextCreate(NULL, 128, 128,
|
|
|
CGImageGetBitsPerComponent(imageRef),
|
|
|
bytesPerRow,
|
|
|
CGImageGetColorSpace(imageRef),
|
|
|
kCGImageAlphaPremultipliedFirst);
|
|
|
if (context)
|
|
|
{
|
|
|
CGContextDrawImage(context, CGRectMake(0, 0, 128, 128),
|
|
|
imageRef);
|
|
|
CGImageRelease(imageRef);
|
|
|
imageRef = CGBitmapContextCreateImage(context);
|
|
|
CGContextRelease(context);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
CGImageDestinationAddImage(destRef, imageRef, NULL);
|
|
|
CGImageDestinationFinalize(destRef);
|
|
|
CFRelease(destRef);
|
|
|
}
|
|
|
|
|
|
CGImageRelease(imageRef);
|
|
|
}
|
|
|
|
|
|
CFRelease(sourceRef);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (outUrl)
|
|
|
CFRelease(outUrl);
|
|
|
|
|
|
if (icnsFileUrl)
|
|
|
CFRelease(icnsFileUrl);
|
|
|
}
|
|
|
#endif /* HAVE_APPLICATIONSERVICES_H */
|
|
|
|
|
|
/*
|
|
|
* Close the PPD and set the type...
|
|
|
*/
|
|
|
|
|
|
ppdClose(ppd);
|
|
|
}
|
|
|
else if (!access(ppd_name, 0))
|
|
|
{
|
|
|
int pline; /* PPD line number */
|
|
|
ppd_status_t pstatus; /* PPD load status */
|
|
|
|
|
|
|
|
|
pstatus = ppdLastError(&pline);
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR, "PPD file for %s cannot be loaded.", p->name);
|
|
|
|
|
|
if (pstatus <= PPD_ALLOC_ERROR)
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR, "%s: %s", ppd_name, strerror(errno));
|
|
|
else
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR, "%s on line %d of %s.", ppdErrorString(pstatus), pline, ppd_name);
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_INFO,
|
|
|
"Hint: Run \"cupstestppd %s\" and fix any errors.",
|
|
|
ppd_name);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (((!strncmp(p->device_uri, "ipp://", 6) ||
|
|
|
!strncmp(p->device_uri, "ipps://", 7)) &&
|
|
|
(strstr(p->device_uri, "/printers/") != NULL ||
|
|
|
strstr(p->device_uri, "/classes/") != NULL)) ||
|
|
|
((strstr(p->device_uri, "._ipp.") != NULL ||
|
|
|
strstr(p->device_uri, "._ipps.") != NULL) &&
|
|
|
!strcmp(p->device_uri + strlen(p->device_uri) - 5, "/cups")))
|
|
|
{
|
|
|
/*
|
|
|
* Tell the client this is really a hard-wired remote printer.
|
|
|
*/
|
|
|
|
|
|
p->type |= CUPS_PRINTER_REMOTE;
|
|
|
|
|
|
/*
|
|
|
* Then set the make-and-model accordingly...
|
|
|
*/
|
|
|
|
|
|
ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_TEXT,
|
|
|
"printer-make-and-model", NULL, "Remote Printer");
|
|
|
|
|
|
/*
|
|
|
* Print all files directly...
|
|
|
*/
|
|
|
|
|
|
p->raw = 1;
|
|
|
p->remote = 1;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
/*
|
|
|
* Otherwise we have neither - treat this as a "dumb" printer
|
|
|
* with no PPD file...
|
|
|
*/
|
|
|
|
|
|
ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_TEXT,
|
|
|
"printer-make-and-model", NULL, "Local Raw Printer");
|
|
|
|
|
|
p->raw = 1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
ippAddIntegers(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_ENUM,
|
|
|
"finishings-supported", num_finishings, finishings);
|
|
|
ippAddInteger(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_ENUM,
|
|
|
"finishings-default", IPP_FINISHINGS_NONE);
|
|
|
|
|
|
if (ppd && p->pc)
|
|
|
{
|
|
|
/*
|
|
|
* Save cached PPD attributes to disk...
|
|
|
*/
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG, "load_ppd: Saving %s...", cache_name);
|
|
|
|
|
|
_ppdCacheWriteFile(p->pc, cache_name, p->ppd_attrs);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
/*
|
|
|
* Remove cache files...
|
|
|
*/
|
|
|
|
|
|
if (cache_info.st_mtime)
|
|
|
unlink(cache_name);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'new_media_col()' - Create a media-col collection value.
|
|
|
*/
|
|
|
|
|
|
static ipp_t * /* O - Collection value */
|
|
|
new_media_col(pwg_size_t *size) /* I - media-size/margin values */
|
|
|
{
|
|
|
ipp_t *media_col, /* Collection value */
|
|
|
*media_size; /* media-size value */
|
|
|
|
|
|
|
|
|
media_col = ippNew();
|
|
|
|
|
|
media_size = ippNew();
|
|
|
ippAddInteger(media_size, IPP_TAG_PRINTER, IPP_TAG_INTEGER, "x-dimension", size->width);
|
|
|
ippAddInteger(media_size, IPP_TAG_PRINTER, IPP_TAG_INTEGER, "y-dimension", size->length);
|
|
|
ippAddCollection(media_col, IPP_TAG_PRINTER, "media-size", media_size);
|
|
|
ippDelete(media_size);
|
|
|
|
|
|
ippAddInteger(media_col, IPP_TAG_PRINTER, IPP_TAG_INTEGER, "media-bottom-margin", size->bottom);
|
|
|
ippAddInteger(media_col, IPP_TAG_PRINTER, IPP_TAG_INTEGER, "media-left-margin", size->left);
|
|
|
ippAddInteger(media_col, IPP_TAG_PRINTER, IPP_TAG_INTEGER, "media-right-margin", size->right);
|
|
|
ippAddInteger(media_col, IPP_TAG_PRINTER, IPP_TAG_INTEGER, "media-top-margin", size->top);
|
|
|
|
|
|
return (media_col);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'write_xml_string()' - Write a string with XML escaping.
|
|
|
*/
|
|
|
|
|
|
static void
|
|
|
write_xml_string(cups_file_t *fp, /* I - File to write to */
|
|
|
const char *s) /* I - String to write */
|
|
|
{
|
|
|
const char *start; /* Start of current sequence */
|
|
|
|
|
|
|
|
|
if (!s)
|
|
|
return;
|
|
|
|
|
|
for (start = s; *s; s ++)
|
|
|
{
|
|
|
if (*s == '&')
|
|
|
{
|
|
|
if (s > start)
|
|
|
cupsFileWrite(fp, start, (size_t)(s - start));
|
|
|
|
|
|
cupsFilePuts(fp, "&");
|
|
|
start = s + 1;
|
|
|
}
|
|
|
else if (*s == '<')
|
|
|
{
|
|
|
if (s > start)
|
|
|
cupsFileWrite(fp, start, (size_t)(s - start));
|
|
|
|
|
|
cupsFilePuts(fp, "<");
|
|
|
start = s + 1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (s > start)
|
|
|
cupsFilePuts(fp, start);
|
|
|
}
|
