mirror of https://gitee.com/openkylin/cups.git
2911 lines
77 KiB
C++
2911 lines
77 KiB
C++
/*
|
||
* PPD/driver support for CUPS.
|
||
*
|
||
* This program handles listing and installing static PPD files, PPD files
|
||
* created from driver information files, and dynamically generated PPD files
|
||
* using driver helper programs.
|
||
*
|
||
* Copyright © 2021-2022 by OpenPrinting.
|
||
* Copyright © 2007-2019 by Apple Inc.
|
||
* Copyright © 1997-2007 by Easy Software Products.
|
||
*
|
||
* Licensed under Apache License v2.0. See the file "LICENSE" for more
|
||
* information.
|
||
*/
|
||
|
||
/*
|
||
* Include necessary headers...
|
||
*/
|
||
|
||
#include "util.h"
|
||
#include <cups/dir.h>
|
||
#include <cups/transcode.h>
|
||
#include <cups/ppd-private.h>
|
||
#include <ppdc/ppdc.h>
|
||
#include <regex.h>
|
||
|
||
|
||
/*
|
||
* Constants...
|
||
*/
|
||
|
||
#define PPD_SYNC 0x50504441 /* Sync word for ppds.dat (PPDA) */
|
||
#define PPD_MAX_LANG 32 /* Maximum languages */
|
||
#define PPD_MAX_PROD 32 /* Maximum products */
|
||
#define PPD_MAX_VERS 32 /* Maximum versions */
|
||
|
||
#define PPD_TYPE_POSTSCRIPT 0 /* PostScript PPD */
|
||
#define PPD_TYPE_PDF 1 /* PDF PPD */
|
||
#define PPD_TYPE_RASTER 2 /* CUPS raster PPD */
|
||
#define PPD_TYPE_FAX 3 /* Facsimile/MFD PPD */
|
||
#define PPD_TYPE_UNKNOWN 4 /* Other/hybrid PPD */
|
||
#define PPD_TYPE_DRV 5 /* Driver info file */
|
||
#define PPD_TYPE_ARCHIVE 6 /* Archive file */
|
||
|
||
#define TAR_BLOCK 512 /* Number of bytes in a block */
|
||
#define TAR_BLOCKS 10 /* Blocking factor */
|
||
|
||
#define TAR_MAGIC "ustar" /* 5 chars and a null */
|
||
#define TAR_VERSION "00" /* POSIX tar version */
|
||
|
||
#define TAR_OLDNORMAL '\0' /* Normal disk file, Unix compat */
|
||
#define TAR_NORMAL '0' /* Normal disk file */
|
||
#define TAR_LINK '1' /* Link to previously dumped file */
|
||
#define TAR_SYMLINK '2' /* Symbolic link */
|
||
#define TAR_CHR '3' /* Character special file */
|
||
#define TAR_BLK '4' /* Block special file */
|
||
#define TAR_DIR '5' /* Directory */
|
||
#define TAR_FIFO '6' /* FIFO special file */
|
||
#define TAR_CONTIG '7' /* Contiguous file */
|
||
|
||
|
||
/*
|
||
* PPD information structures...
|
||
*/
|
||
|
||
typedef struct /**** PPD record ****/
|
||
{
|
||
time_t mtime; /* Modification time */
|
||
off_t size; /* Size in bytes */
|
||
int model_number; /* cupsModelNumber */
|
||
int type; /* ppd-type */
|
||
char filename[512], /* Filename */
|
||
name[256], /* PPD name */
|
||
languages[PPD_MAX_LANG][6],
|
||
/* LanguageVersion/cupsLanguages */
|
||
products[PPD_MAX_PROD][128],
|
||
/* Product strings */
|
||
psversions[PPD_MAX_VERS][32],
|
||
/* PSVersion strings */
|
||
make[128], /* Manufacturer */
|
||
make_and_model[128], /* NickName/ModelName */
|
||
device_id[256], /* IEEE 1284 Device ID */
|
||
scheme[128]; /* PPD scheme */
|
||
} ppd_rec_t;
|
||
|
||
typedef struct /**** In-memory record ****/
|
||
{
|
||
int found; /* 1 if PPD is found */
|
||
int matches; /* Match count */
|
||
ppd_rec_t record; /* PPDs.dat record */
|
||
} ppd_info_t;
|
||
|
||
typedef union /**** TAR record format ****/
|
||
{
|
||
unsigned char all[TAR_BLOCK]; /* Raw data block */
|
||
struct
|
||
{
|
||
char pathname[100], /* Destination path */
|
||
mode[8], /* Octal file permissions */
|
||
uid[8], /* Octal user ID */
|
||
gid[8], /* Octal group ID */
|
||
size[12], /* Octal size in bytes */
|
||
mtime[12], /* Octal modification time */
|
||
chksum[8], /* Octal checksum value */
|
||
linkflag, /* File type */
|
||
linkname[100], /* Source path for link */
|
||
magic[6], /* Magic string */
|
||
version[2], /* Format version */
|
||
uname[32], /* User name */
|
||
gname[32], /* Group name */
|
||
devmajor[8], /* Octal device major number */
|
||
devminor[8], /* Octal device minor number */
|
||
prefix[155]; /* Prefix for long filenames */
|
||
} header;
|
||
} tar_rec_t;
|
||
|
||
|
||
/*
|
||
* Globals...
|
||
*/
|
||
|
||
static cups_array_t *Inodes = NULL, /* Inodes of directories we've visited */
|
||
*PPDsByName = NULL,
|
||
/* PPD files sorted by filename and name */
|
||
*PPDsByMakeModel = NULL;
|
||
/* PPD files sorted by make and model */
|
||
static int ChangedPPD; /* Did we change the PPD database? */
|
||
static const char * const PPDTypes[] = /* ppd-type values */
|
||
{
|
||
"postscript",
|
||
"pdf",
|
||
"raster",
|
||
"fax",
|
||
"object",
|
||
"object-direct",
|
||
"object-storage",
|
||
"unknown",
|
||
"drv",
|
||
"archive"
|
||
};
|
||
|
||
|
||
/*
|
||
* Local functions...
|
||
*/
|
||
|
||
static ppd_info_t *add_ppd(const char *filename, const char *name,
|
||
const char *language, const char *make,
|
||
const char *make_and_model,
|
||
const char *device_id, const char *product,
|
||
const char *psversion, time_t mtime,
|
||
size_t size, int model_number, int type,
|
||
const char *scheme);
|
||
static int cat_drv(const char *name, int request_id);
|
||
static void cat_ppd(const char *name, int request_id);
|
||
static int cat_static(const char *name, int request_id);
|
||
static int cat_tar(const char *name, int request_id);
|
||
static int compare_inodes(struct stat *a, struct stat *b);
|
||
static int compare_matches(const ppd_info_t *p0,
|
||
const ppd_info_t *p1);
|
||
static int compare_names(const ppd_info_t *p0,
|
||
const ppd_info_t *p1);
|
||
static int compare_ppds(const ppd_info_t *p0,
|
||
const ppd_info_t *p1);
|
||
static void dump_ppds_dat(const char *filename);
|
||
static void free_array(cups_array_t *a);
|
||
static cups_file_t *get_file(const char *name, int request_id,
|
||
const char *subdir, char *buffer,
|
||
size_t bufsize, char **subfile);
|
||
static void list_ppds(int request_id, int limit, const char *opt);
|
||
static int load_drivers(cups_array_t *include,
|
||
cups_array_t *exclude);
|
||
static int load_drv(const char *filename, const char *name,
|
||
cups_file_t *fp, time_t mtime, off_t size);
|
||
static void load_ppd(const char *filename, const char *name,
|
||
const char *scheme, struct stat *fileinfo,
|
||
ppd_info_t *ppd, cups_file_t *fp, off_t end);
|
||
static int load_ppds(const char *d, const char *p, int descend);
|
||
static void load_ppds_dat(char *filename, size_t filesize,
|
||
int verbose);
|
||
static int load_tar(const char *filename, const char *name,
|
||
cups_file_t *fp, time_t mtime, off_t size);
|
||
static int read_tar(cups_file_t *fp, char *name, size_t namesize,
|
||
struct stat *info);
|
||
static regex_t *regex_device_id(const char *device_id);
|
||
static regex_t *regex_string(const char *s);
|
||
|
||
|
||
/*
|
||
* 'main()' - Scan for drivers and return an IPP response.
|
||
*
|
||
* Usage:
|
||
*
|
||
* cups-driverd request_id limit options
|
||
*/
|
||
|
||
int /* O - Exit code */
|
||
main(int argc, /* I - Number of command-line args */
|
||
char *argv[]) /* I - Command-line arguments */
|
||
{
|
||
/*
|
||
* Install or list PPDs...
|
||
*/
|
||
|
||
if (argc == 3 && !strcmp(argv[1], "cat"))
|
||
cat_ppd(argv[2], 0);
|
||
else if ((argc == 2 || argc == 3) && !strcmp(argv[1], "dump"))
|
||
dump_ppds_dat(argv[2]);
|
||
else if (argc == 4 && !strcmp(argv[1], "get"))
|
||
cat_ppd(argv[3], atoi(argv[2]));
|
||
else if (argc == 5 && !strcmp(argv[1], "list"))
|
||
list_ppds(atoi(argv[2]), atoi(argv[3]), argv[4]);
|
||
else
|
||
{
|
||
fputs("Usage: cups-driverd cat ppd-name\n", stderr);
|
||
fputs("Usage: cups-driverd dump\n", stderr);
|
||
fputs("Usage: cups-driverd get request_id ppd-name\n", stderr);
|
||
fputs("Usage: cups-driverd list request_id limit options\n", stderr);
|
||
return (1);
|
||
}
|
||
}
|
||
|
||
|
||
/*
|
||
* 'add_ppd()' - Add a PPD file.
|
||
*/
|
||
|
||
static ppd_info_t * /* O - PPD */
|
||
add_ppd(const char *filename, /* I - PPD filename */
|
||
const char *name, /* I - PPD name */
|
||
const char *language, /* I - LanguageVersion */
|
||
const char *make, /* I - Manufacturer */
|
||
const char *make_and_model, /* I - NickName/ModelName */
|
||
const char *device_id, /* I - 1284DeviceID */
|
||
const char *product, /* I - Product */
|
||
const char *psversion, /* I - PSVersion */
|
||
time_t mtime, /* I - Modification time */
|
||
size_t size, /* I - File size */
|
||
int model_number, /* I - Model number */
|
||
int type, /* I - Driver type */
|
||
const char *scheme) /* I - PPD scheme */
|
||
{
|
||
ppd_info_t *ppd; /* PPD */
|
||
|
||
|
||
/*
|
||
* Add a new PPD file...
|
||
*/
|
||
|
||
if ((ppd = (ppd_info_t *)calloc(1, sizeof(ppd_info_t))) == NULL)
|
||
{
|
||
fprintf(stderr,
|
||
"ERROR: [cups-driverd] Ran out of memory for %d PPD files!\n",
|
||
cupsArrayCount(PPDsByName));
|
||
return (NULL);
|
||
}
|
||
|
||
/*
|
||
* Zero-out the PPD data and copy the values over...
|
||
*/
|
||
|
||
ppd->found = 1;
|
||
ppd->record.mtime = mtime;
|
||
ppd->record.size = (off_t)size;
|
||
ppd->record.model_number = model_number;
|
||
ppd->record.type = type;
|
||
|
||
strlcpy(ppd->record.filename, filename, sizeof(ppd->record.filename));
|
||
strlcpy(ppd->record.name, name, sizeof(ppd->record.name));
|
||
strlcpy(ppd->record.languages[0], language,
|
||
sizeof(ppd->record.languages[0]));
|
||
strlcpy(ppd->record.products[0], product, sizeof(ppd->record.products[0]));
|
||
strlcpy(ppd->record.psversions[0], psversion,
|
||
sizeof(ppd->record.psversions[0]));
|
||
strlcpy(ppd->record.make, make, sizeof(ppd->record.make));
|
||
strlcpy(ppd->record.make_and_model, make_and_model,
|
||
sizeof(ppd->record.make_and_model));
|
||
strlcpy(ppd->record.device_id, device_id, sizeof(ppd->record.device_id));
|
||
strlcpy(ppd->record.scheme, scheme, sizeof(ppd->record.scheme));
|
||
|
||
/*
|
||
* Add the PPD to the PPD arrays...
|
||
*/
|
||
|
||
cupsArrayAdd(PPDsByName, ppd);
|
||
cupsArrayAdd(PPDsByMakeModel, ppd);
|
||
|
||
/*
|
||
* Return the new PPD pointer...
|
||
*/
|
||
|
||
return (ppd);
|
||
}
|
||
|
||
|
||
/*
|
||
* 'cat_drv()' - Generate a PPD from a driver info file.
|
||
*/
|
||
|
||
static int /* O - Exit code */
|
||
cat_drv(const char *name, /* I - PPD name */
|
||
int request_id) /* I - Request ID for response? */
|
||
{
|
||
cups_file_t *fp; // File pointer
|
||
ppdcSource *src; // PPD source file data
|
||
ppdcDriver *d; // Current driver
|
||
cups_file_t *out; // Stdout via CUPS file API
|
||
char message[2048], // status-message
|
||
filename[1024], // Full path to .drv file(s)
|
||
scheme[32], // URI scheme ("drv")
|
||
userpass[256], // User/password info (unused)
|
||
host[2], // Hostname (unused)
|
||
resource[1024], // Resource path (/dir/to/filename.drv)
|
||
*pc_file_name; // Filename portion of URI
|
||
int port; // Port number (unused)
|
||
|
||
|
||
// Pull out the path to the .drv file...
|
||
if (httpSeparateURI(HTTP_URI_CODING_ALL, name, scheme, sizeof(scheme),
|
||
userpass, sizeof(userpass), host, sizeof(host), &port,
|
||
resource, sizeof(resource)) < HTTP_URI_OK)
|
||
{
|
||
fprintf(stderr, "ERROR: Bad PPD name \"%s\".\n", name);
|
||
|
||
if (request_id)
|
||
{
|
||
snprintf(message, sizeof(message), "Bad PPD name \"%s\".", name);
|
||
|
||
cupsdSendIPPHeader(IPP_NOT_FOUND, request_id);
|
||
cupsdSendIPPGroup(IPP_TAG_OPERATION);
|
||
cupsdSendIPPString(IPP_TAG_CHARSET, "attributes-charset", "utf-8");
|
||
cupsdSendIPPString(IPP_TAG_LANGUAGE, "attributes-natural-language",
|
||
"en-US");
|
||
cupsdSendIPPString(IPP_TAG_TEXT, "status-message", message);
|
||
cupsdSendIPPTrailer();
|
||
}
|
||
|
||
return (1);
|
||
}
|
||
|
||
if ((fp = get_file(resource, request_id, "drv", filename, sizeof(filename), &pc_file_name)) == NULL || !pc_file_name)
|
||
return (1);
|
||
|
||
src = new ppdcSource(filename, fp);
|
||
|
||
for (d = (ppdcDriver *)src->drivers->first();
|
||
d;
|
||
d = (ppdcDriver *)src->drivers->next())
|
||
if (!strcmp(pc_file_name, d->pc_file_name->value) ||
|
||
(d->file_name && !strcmp(pc_file_name, d->file_name->value)))
|
||
break;
|
||
|
||
if (d)
|
||
{
|
||
ppdcArray *locales; // Locale names
|
||
ppdcCatalog *catalog; // Message catalog in .drv file
|
||
|
||
|
||
fprintf(stderr, "DEBUG2: [cups-driverd] %u locales defined in \"%s\"...\n", (unsigned)src->po_files->count, filename);
|
||
|
||
locales = new ppdcArray();
|
||
for (catalog = (ppdcCatalog *)src->po_files->first();
|
||
catalog;
|
||
catalog = (ppdcCatalog *)src->po_files->next())
|
||
{
|
||
fprintf(stderr, "DEBUG2: [cups-driverd] Adding locale \"%s\"...\n",
|
||
catalog->locale->value);
|
||
catalog->locale->retain();
|
||
locales->add(catalog->locale);
|
||
}
|
||
|
||
if (request_id)
|
||
{
|
||
cupsdSendIPPHeader(IPP_OK, request_id);
|
||
cupsdSendIPPGroup(IPP_TAG_OPERATION);
|
||
cupsdSendIPPString(IPP_TAG_CHARSET, "attributes-charset", "utf-8");
|
||
cupsdSendIPPString(IPP_TAG_LANGUAGE, "attributes-natural-language",
|
||
"en-US");
|
||
cupsdSendIPPTrailer();
|
||
fflush(stdout);
|
||
}
|
||
|
||
out = cupsFileStdout();
|
||
d->write_ppd_file(out, NULL, locales, src, PPDC_LFONLY);
|
||
cupsFileClose(out);
|
||
|
||
locales->release();
|
||
}
|
||
else
|
||
{
|
||
fprintf(stderr, "ERROR: PPD \"%s\" not found.\n", name);
|
||
|
||
if (request_id)
|
||
{
|
||
snprintf(message, sizeof(message), "PPD \"%s\" not found.", name);
|
||
|
||
cupsdSendIPPHeader(IPP_NOT_FOUND, request_id);
|
||
cupsdSendIPPGroup(IPP_TAG_OPERATION);
|
||
cupsdSendIPPString(IPP_TAG_CHARSET, "attributes-charset", "utf-8");
|
||
cupsdSendIPPString(IPP_TAG_LANGUAGE, "attributes-natural-language",
|
||
"en-US");
|
||
cupsdSendIPPString(IPP_TAG_TEXT, "status-message", message);
|
||
cupsdSendIPPTrailer();
|
||
}
|
||
}
|
||
|
||
src->release();
|
||
cupsFileClose(fp);
|
||
|
||
return (!d);
|
||
}
|
||
|
||
|
||
/*
|
||
* 'cat_ppd()' - Copy a PPD file to stdout.
|
||
*/
|
||
|
||
static void
|
||
cat_ppd(const char *name, /* I - PPD name */
|
||
int request_id) /* I - Request ID for response? */
|
||
{
|
||
char scheme[256], /* Scheme from PPD name */
|
||
*sptr, /* Pointer into scheme */
|
||
line[1024], /* Line/filename */
|
||
message[2048]; /* status-message */
|
||
|
||
|
||
/*
|
||
* Figure out if this is a static or dynamic PPD file...
|
||
*/
|
||
|
||
if (strstr(name, "../"))
|
||
{
|
||
fputs("ERROR: Invalid PPD name.\n", stderr);
|
||
exit(1);
|
||
}
|
||
|
||
strlcpy(scheme, name, sizeof(scheme));
|
||
if ((sptr = strchr(scheme, ':')) != NULL)
|
||
{
|
||
*sptr = '\0';
|
||
|
||
if (!strcmp(scheme, "file"))
|
||
{
|
||
/*
|
||
* "file:name" == "name"...
|
||
*/
|
||
|
||
name += 5;
|
||
|
||
while (*name == '/')
|
||
name ++;
|
||
|
||
if (!strstr(name, ".tar/") && !strstr(name, ".tar.gz/"))
|
||
scheme[0] = '\0';
|
||
}
|
||
}
|
||
else
|
||
scheme[0] = '\0';
|
||
|
||
if (request_id > 0)
|
||
puts("Content-Type: application/ipp\n");
|
||
|
||
if (!scheme[0])
|
||
exit(cat_static(name, request_id));
|
||
else if (!strcmp(scheme, "drv"))
|
||
exit(cat_drv(name, request_id));
|
||
else if (!strcmp(scheme, "file"))
|
||
exit(cat_tar(name, request_id));
|
||
else
|
||
{
|
||
/*
|
||
* Dynamic PPD, see if we have a driver program to support it...
|
||
*/
|
||
|
||
const char *serverbin; /* CUPS_SERVERBIN env var */
|
||
char *argv[4]; /* Arguments for program */
|
||
|
||
|
||
if ((serverbin = getenv("CUPS_SERVERBIN")) == NULL)
|
||
serverbin = CUPS_SERVERBIN;
|
||
|
||
snprintf(line, sizeof(line), "%s/driver/%s", serverbin, scheme);
|
||
if (access(line, X_OK))
|
||
{
|
||
/*
|
||
* File does not exist or is not executable...
|
||
*/
|
||
|
||
fprintf(stderr, "ERROR: [cups-driverd] Unable to access \"%s\" - %s\n",
|
||
line, strerror(errno));
|
||
|
||
if (request_id > 0)
|
||
{
|
||
snprintf(message, sizeof(message), "Unable to access \"%s\" - %s",
|
||
line, strerror(errno));
|
||
|
||
cupsdSendIPPHeader(IPP_NOT_FOUND, request_id);
|
||
cupsdSendIPPGroup(IPP_TAG_OPERATION);
|
||
cupsdSendIPPString(IPP_TAG_CHARSET, "attributes-charset", "utf-8");
|
||
cupsdSendIPPString(IPP_TAG_LANGUAGE, "attributes-natural-language",
|
||
"en-US");
|
||
cupsdSendIPPString(IPP_TAG_TEXT, "status-message", message);
|
||
cupsdSendIPPTrailer();
|
||
}
|
||
|
||
exit(1);
|
||
}
|
||
|
||
/*
|
||
* Yes, let it cat the PPD file...
|
||
*/
|
||
|
||
if (request_id)
|
||
{
|
||
cupsdSendIPPHeader(IPP_OK, request_id);
|
||
cupsdSendIPPGroup(IPP_TAG_OPERATION);
|
||
cupsdSendIPPString(IPP_TAG_CHARSET, "attributes-charset", "utf-8");
|
||
cupsdSendIPPString(IPP_TAG_LANGUAGE, "attributes-natural-language",
|
||
"en-US");
|
||
cupsdSendIPPTrailer();
|
||
}
|
||
|
||
argv[0] = scheme;
|
||
argv[1] = (char *)"cat";
|
||
argv[2] = (char *)name;
|
||
argv[3] = NULL;
|
||
|
||
if (cupsdExec(line, argv))
|
||
{
|
||
/*
|
||
* Unable to execute driver...
|
||
*/
|
||
|
||
fprintf(stderr, "ERROR: [cups-driverd] Unable to execute \"%s\" - %s\n",
|
||
line, strerror(errno));
|
||
exit(1);
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Exit with no errors...
|
||
*/
|
||
|
||
exit(0);
|
||
}
|
||
|
||
|
||
/*
|
||
* 'copy_static()' - Copy a static PPD file to stdout.
|
||
*/
|
||
|
||
static int /* O - Exit code */
|
||
cat_static(const char *name, /* I - PPD name */
|
||
int request_id) /* I - Request ID for response? */
|
||
{
|
||
cups_file_t *fp; /* PPD file */
|
||
char filename[1024], /* PPD filename */
|
||
line[1024]; /* Line buffer */
|
||
|
||
|
||
if ((fp = get_file(name, request_id, "model", filename, sizeof(filename),
|
||
NULL)) == NULL)
|
||
return (1);
|
||
|
||
if (request_id)
|
||
{
|
||
cupsdSendIPPHeader(IPP_OK, request_id);
|
||
cupsdSendIPPGroup(IPP_TAG_OPERATION);
|
||
cupsdSendIPPString(IPP_TAG_CHARSET, "attributes-charset", "utf-8");
|
||
cupsdSendIPPString(IPP_TAG_LANGUAGE, "attributes-natural-language",
|
||
"en-US");
|
||
cupsdSendIPPTrailer();
|
||
}
|
||
|
||
/*
|
||
* Now copy the file to stdout...
|
||
*/
|
||
|
||
while (cupsFileGets(fp, line, sizeof(line)))
|
||
puts(line);
|
||
|
||
cupsFileClose(fp);
|
||
|
||
return (0);
|
||
}
|
||
|
||
|
||
/*
|
||
* 'cat_tar()' - Copy an archived PPD file to stdout.
|
||
*/
|
||
|
||
static int /* O - Exit code */
|
||
cat_tar(const char *name, /* I - PPD name */
|
||
int request_id) /* I - Request ID */
|
||
{
|
||
cups_file_t *fp; /* Archive file pointer */
|
||
char filename[1024], /* Archive filename */
|
||
*ppdname, /* PPD filename in archive */
|
||
curname[256], /* Current name in archive */
|
||
buffer[8192]; /* Copy buffer */
|
||
struct stat curinfo; /* Current file info in archive */
|
||
off_t total, /* Total bytes copied */
|
||
next; /* Offset for next record in archive */
|
||
ssize_t bytes; /* Bytes read */
|
||
|
||
|
||
/*
|
||
* Open the archive file...
|
||
*/
|
||
|
||
if ((fp = get_file(name, request_id, "model", filename, sizeof(filename),
|
||
&ppdname)) == NULL || !ppdname)
|
||
return (1);
|
||
|
||
/*
|
||
* Scan the archive for the PPD...
|
||
*/
|
||
|
||
while (read_tar(fp, curname, sizeof(curname), &curinfo))
|
||
{
|
||
next = cupsFileTell(fp) + ((curinfo.st_size + TAR_BLOCK - 1) &
|
||
~(TAR_BLOCK - 1));
|
||
|
||
if (!strcmp(ppdname, curname))
|
||
{
|
||
if (request_id)
|
||
{
|
||
cupsdSendIPPHeader(IPP_OK, request_id);
|
||
cupsdSendIPPGroup(IPP_TAG_OPERATION);
|
||
cupsdSendIPPString(IPP_TAG_CHARSET, "attributes-charset", "utf-8");
|
||
cupsdSendIPPString(IPP_TAG_LANGUAGE, "attributes-natural-language",
|
||
"en-US");
|
||
cupsdSendIPPTrailer();
|
||
}
|
||
|
||
for (total = 0; total < curinfo.st_size; total += bytes)
|
||
{
|
||
if ((size_t)(bytes = (curinfo.st_size - total)) > sizeof(buffer))
|
||
bytes = sizeof(buffer);
|
||
|
||
if ((bytes = cupsFileRead(fp, buffer, (size_t)bytes)) < 0)
|
||
{
|
||
if (errno == EINTR || errno == EAGAIN)
|
||
{
|
||
bytes = 0;
|
||
}
|
||
else
|
||
{
|
||
perror("ERROR: [cups-driverd] Read error");
|
||
break;
|
||
}
|
||
}
|
||
else if (bytes > 0 && fwrite(buffer, (size_t)bytes, 1, stdout) != 1)
|
||
break;
|
||
}
|
||
|
||
cupsFileClose(fp);
|
||
return (0);
|
||
}
|
||
|
||
if (cupsFileTell(fp) != next)
|
||
{
|
||
if (cupsFileSeek(fp, next) != next)
|
||
break;
|
||
}
|
||
}
|
||
|
||
cupsFileClose(fp);
|
||
|
||
fprintf(stderr, "ERROR: PPD \"%s\" not found.\n", name);
|
||
|
||
if (request_id)
|
||
{
|
||
snprintf(buffer, sizeof(buffer), "PPD \"%s\" not found.", name);
|
||
|
||
cupsdSendIPPHeader(IPP_NOT_FOUND, request_id);
|
||
cupsdSendIPPGroup(IPP_TAG_OPERATION);
|
||
cupsdSendIPPString(IPP_TAG_CHARSET, "attributes-charset", "utf-8");
|
||
cupsdSendIPPString(IPP_TAG_LANGUAGE, "attributes-natural-language",
|
||
"en-US");
|
||
cupsdSendIPPString(IPP_TAG_TEXT, "status-message", buffer);
|
||
cupsdSendIPPTrailer();
|
||
}
|
||
|
||
return (1);
|
||
}
|
||
|
||
|
||
/*
|
||
* 'compare_inodes()' - Compare two inodes.
|
||
*/
|
||
|
||
static int /* O - Result of comparison */
|
||
compare_inodes(struct stat *a, /* I - First inode */
|
||
struct stat *b) /* I - Second inode */
|
||
{
|
||
if (a->st_dev != b->st_dev)
|
||
return (a->st_dev - b->st_dev);
|
||
else
|
||
return (a->st_ino - b->st_ino);
|
||
}
|
||
|
||
|
||
/*
|
||
* 'compare_matches()' - Compare PPD match scores for sorting.
|
||
*/
|
||
|
||
static int
|
||
compare_matches(const ppd_info_t *p0, /* I - First PPD */
|
||
const ppd_info_t *p1) /* I - Second PPD */
|
||
{
|
||
if (p1->matches != p0->matches)
|
||
return (p1->matches - p0->matches);
|
||
else
|
||
return (cupsdCompareNames(p0->record.make_and_model,
|
||
p1->record.make_and_model));
|
||
}
|
||
|
||
|
||
/*
|
||
* 'compare_names()' - Compare PPD filenames for sorting.
|
||
*/
|
||
|
||
static int /* O - Result of comparison */
|
||
compare_names(const ppd_info_t *p0, /* I - First PPD file */
|
||
const ppd_info_t *p1) /* I - Second PPD file */
|
||
{
|
||
int diff; /* Difference between strings */
|
||
|
||
|
||
if ((diff = strcmp(p0->record.filename, p1->record.filename)) != 0)
|
||
return (diff);
|
||
else
|
||
return (strcmp(p0->record.name, p1->record.name));
|
||
}
|
||
|
||
|
||
/*
|
||
* 'compare_ppds()' - Compare PPD file make and model names for sorting.
|
||
*/
|
||
|
||
static int /* O - Result of comparison */
|
||
compare_ppds(const ppd_info_t *p0, /* I - First PPD file */
|
||
const ppd_info_t *p1) /* I - Second PPD file */
|
||
{
|
||
int diff; /* Difference between strings */
|
||
|
||
|
||
/*
|
||
* First compare manufacturers...
|
||
*/
|
||
|
||
if ((diff = _cups_strcasecmp(p0->record.make, p1->record.make)) != 0)
|
||
return (diff);
|
||
else if ((diff = cupsdCompareNames(p0->record.make_and_model,
|
||
p1->record.make_and_model)) != 0)
|
||
return (diff);
|
||
else if ((diff = strcmp(p0->record.languages[0],
|
||
p1->record.languages[0])) != 0)
|
||
return (diff);
|
||
else
|
||
return (compare_names(p0, p1));
|
||
}
|
||
|
||
|
||
/*
|
||
* 'dump_ppds_dat()' - Dump the contents of the ppds.dat file.
|
||
*/
|
||
|
||
static void
|
||
dump_ppds_dat(const char *filename) /* I - Filename */
|
||
{
|
||
char temp[1024]; /* ppds.dat filename */
|
||
ppd_info_t *ppd; /* Current PPD */
|
||
|
||
|
||
/*
|
||
* See if we a PPD database file...
|
||
*/
|
||
|
||
if (filename)
|
||
strlcpy(temp, filename, sizeof(temp));
|
||
else
|
||
temp[0] = '\0';
|
||
|
||
load_ppds_dat(temp, sizeof(temp), 0);
|
||
|
||
puts("mtime,size,model_number,type,filename,name,languages0,products0,"
|
||
"psversions0,make,make_and_model,device_id,scheme");
|
||
for (ppd = (ppd_info_t *)cupsArrayFirst(PPDsByName);
|
||
ppd;
|
||
ppd = (ppd_info_t *)cupsArrayNext(PPDsByName))
|
||
printf("%d,%ld,%d,%d,\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"%s\","
|
||
"\"%s\",\"%s\"\n",
|
||
(int)ppd->record.mtime, (long)ppd->record.size,
|
||
ppd->record.model_number, ppd->record.type, ppd->record.filename,
|
||
ppd->record.name, ppd->record.languages[0], ppd->record.products[0],
|
||
ppd->record.psversions[0], ppd->record.make,
|
||
ppd->record.make_and_model, ppd->record.device_id,
|
||
ppd->record.scheme);
|
||
|
||
exit(0);
|
||
}
|
||
|
||
|
||
/*
|
||
* 'free_array()' - Free an array of strings.
|
||
*/
|
||
|
||
static void
|
||
free_array(cups_array_t *a) /* I - Array to free */
|
||
{
|
||
char *ptr; /* Pointer to string */
|
||
|
||
|
||
for (ptr = (char *)cupsArrayFirst(a);
|
||
ptr;
|
||
ptr = (char *)cupsArrayNext(a))
|
||
free(ptr);
|
||
|
||
cupsArrayDelete(a);
|
||
}
|
||
|
||
|
||
/*
|
||
* 'get_file()' - Get the filename associated with a request.
|
||
*/
|
||
|
||
static cups_file_t * /* O - File pointer or NULL */
|
||
get_file(const char *name, /* I - Name */
|
||
int request_id, /* I - Request ID */
|
||
const char *subdir, /* I - Subdirectory for file */
|
||
char *buffer, /* I - Filename buffer */
|
||
size_t bufsize, /* I - Size of filename buffer */
|
||
char **subfile) /* O - Sub-filename */
|
||
{
|
||
cups_file_t *fp; /* File pointer */
|
||
const char *datadir; /* CUPS_DATADIR env var */
|
||
char *bufptr, /* Pointer into filename buffer */
|
||
message[2048]; /* status-message */
|
||
#ifdef __APPLE__
|
||
const char *printerDriver, /* Pointer to .printerDriver extension */
|
||
*slash; /* Pointer to next slash */
|
||
#endif /* __APPLE__ */
|
||
|
||
|
||
if (subfile)
|
||
*subfile = NULL;
|
||
|
||
while (*name == '/')
|
||
name ++;
|
||
|
||
if (strstr(name, "../") || strstr(name, "/.."))
|
||
{
|
||
/*
|
||
* Bad name...
|
||
*/
|
||
|
||
fprintf(stderr, "ERROR: [cups-driverd] Bad PPD name \"%s\".\n", name);
|
||
|
||
if (request_id)
|
||
{
|
||
snprintf(message, sizeof(message), "Bad PPD name \"%s\".", name);
|
||
|
||
cupsdSendIPPHeader(IPP_NOT_FOUND, request_id);
|
||
cupsdSendIPPGroup(IPP_TAG_OPERATION);
|
||
cupsdSendIPPString(IPP_TAG_CHARSET, "attributes-charset", "utf-8");
|
||
cupsdSendIPPString(IPP_TAG_LANGUAGE, "attributes-natural-language",
|
||
"en-US");
|
||
cupsdSendIPPString(IPP_TAG_TEXT, "status-message", message);
|
||
cupsdSendIPPTrailer();
|
||
}
|
||
|
||
return (NULL);
|
||
}
|
||
|
||
/*
|
||
* Try opening the file...
|
||
*/
|
||
|
||
#ifdef __APPLE__
|
||
if (!strncmp(name, "System/Library/Printers/PPDs/Contents/Resources/", 48) ||
|
||
!strncmp(name, "Library/Printers/PPDs/Contents/Resources/", 41) ||
|
||
(!strncmp(name, "System/Library/Printers/", 24) &&
|
||
(printerDriver =
|
||
strstr(name + 24,
|
||
".printerDriver/Contents/Resources/PPDs")) != NULL &&
|
||
(slash = strchr(name + 24, '/')) != NULL &&
|
||
slash > printerDriver) ||
|
||
(!strncmp(name, "Library/Printers/", 17) &&
|
||
(printerDriver =
|
||
strstr(name + 17,
|
||
".printerDriver/Contents/Resources/PPDs")) != NULL &&
|
||
(slash = strchr(name + 17, '/')) != NULL &&
|
||
slash > printerDriver))
|
||
{
|
||
/*
|
||
* Map ppd-name to macOS standard locations...
|
||
*/
|
||
|
||
snprintf(buffer, bufsize, "/%s", name);
|
||
}
|
||
else
|
||
|
||
#elif defined(__linux)
|
||
if (!strncmp(name, "lsb/usr/", 8))
|
||
{
|
||
/*
|
||
* Map ppd-name to LSB standard /usr/share/ppd location...
|
||
*/
|
||
|
||
snprintf(buffer, bufsize, "/usr/share/ppd/%s", name + 8);
|
||
}
|
||
else if (!strncmp(name, "lsb/opt/", 8))
|
||
{
|
||
/*
|
||
* Map ppd-name to LSB standard /opt/share/ppd location...
|
||
*/
|
||
|
||
snprintf(buffer, bufsize, "/opt/share/ppd/%s", name + 8);
|
||
}
|
||
else if (!strncmp(name, "lsb/local/", 10))
|
||
{
|
||
/*
|
||
* Map ppd-name to LSB standard /usr/local/share/ppd location...
|
||
*/
|
||
|
||
snprintf(buffer, bufsize, "/usr/local/share/ppd/%s", name + 10);
|
||
}
|
||
else
|
||
|
||
#endif /* __APPLE__ */
|
||
{
|
||
if ((datadir = getenv("CUPS_DATADIR")) == NULL)
|
||
datadir = CUPS_DATADIR;
|
||
|
||
snprintf(buffer, bufsize, "%s/%s/%s", datadir, subdir, name);
|
||
}
|
||
|
||
/*
|
||
* Strip anything after ".drv/", ".drv.gz/", ".tar/", or ".tar.gz/"...
|
||
*/
|
||
|
||
if (subfile)
|
||
{
|
||
if ((bufptr = strstr(buffer, ".drv/")) != NULL)
|
||
bufptr += 4;
|
||
else if ((bufptr = strstr(buffer, ".drv.gz/")) != NULL)
|
||
bufptr += 7;
|
||
else if ((bufptr = strstr(buffer, ".tar/")) != NULL)
|
||
bufptr += 4;
|
||
else if ((bufptr = strstr(buffer, ".tar.gz/")) != NULL)
|
||
bufptr += 7;
|
||
|
||
if (bufptr)
|
||
{
|
||
*bufptr++ = '\0';
|
||
*subfile = bufptr;
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Try opening the file...
|
||
*/
|
||
|
||
if ((fp = cupsFileOpen(buffer, "r")) == NULL)
|
||
{
|
||
fprintf(stderr, "ERROR: [cups-driverd] Unable to open \"%s\" - %s\n",
|
||
buffer, strerror(errno));
|
||
|
||
if (request_id)
|
||
{
|
||
snprintf(message, sizeof(message), "Unable to open \"%s\" - %s",
|
||
buffer, strerror(errno));
|
||
|
||
cupsdSendIPPHeader(IPP_NOT_FOUND, request_id);
|
||
cupsdSendIPPGroup(IPP_TAG_OPERATION);
|
||
cupsdSendIPPString(IPP_TAG_CHARSET, "attributes-charset", "utf-8");
|
||
cupsdSendIPPString(IPP_TAG_LANGUAGE, "attributes-natural-language",
|
||
"en-US");
|
||
cupsdSendIPPString(IPP_TAG_TEXT, "status-message", message);
|
||
cupsdSendIPPTrailer();
|
||
}
|
||
|
||
return (NULL);
|
||
}
|
||
|
||
return (fp);
|
||
}
|
||
|
||
|
||
/*
|
||
* 'list_ppds()' - List PPD files.
|
||
*/
|
||
|
||
static void
|
||
list_ppds(int request_id, /* I - Request ID */
|
||
int limit, /* I - Limit */
|
||
const char *opt) /* I - Option argument */
|
||
{
|
||
int i; /* Looping vars */
|
||
int count; /* Number of PPDs to send */
|
||
ppd_info_t *ppd; /* Current PPD file */
|
||
cups_file_t *fp; /* ppds.dat file */
|
||
char filename[1024], /* ppds.dat filename */
|
||
model[1024]; /* Model directory */
|
||
const char *cups_datadir; /* CUPS_DATADIR environment variable */
|
||
int num_options; /* Number of options */
|
||
cups_option_t *options; /* Options */
|
||
cups_array_t *requested, /* requested-attributes values */
|
||
*include, /* PPD schemes to include */
|
||
*exclude; /* PPD schemes to exclude */
|
||
const char *device_id, /* ppd-device-id option */
|
||
*language, /* ppd-natural-language option */
|
||
*make, /* ppd-make option */
|
||
*make_and_model, /* ppd-make-and-model option */
|
||
*model_number_str, /* ppd-model-number option */
|
||
*product, /* ppd-product option */
|
||
*psversion, /* ppd-psversion option */
|
||
*type_str; /* ppd-type option */
|
||
int model_number, /* ppd-model-number value */
|
||
type, /* ppd-type value */
|
||
send_device_id, /* Send ppd-device-id? */
|
||
send_make, /* Send ppd-make? */
|
||
send_make_and_model, /* Send ppd-make-and-model? */
|
||
send_model_number, /* Send ppd-model-number? */
|
||
send_name, /* Send ppd-name? */
|
||
send_natural_language, /* Send ppd-natural-language? */
|
||
send_product, /* Send ppd-product? */
|
||
send_psversion, /* Send ppd-psversion? */
|
||
send_type, /* Send ppd-type? */
|
||
sent_header; /* Sent the IPP header? */
|
||
size_t make_and_model_len, /* Length of ppd-make-and-model */
|
||
product_len; /* Length of ppd-product */
|
||
regex_t *device_id_re, /* Regular expression for matching device ID */
|
||
*make_and_model_re; /* Regular expression for matching make and model */
|
||
regmatch_t re_matches[6]; /* Regular expression matches */
|
||
cups_array_t *matches; /* Matching PPDs */
|
||
|
||
|
||
fprintf(stderr,
|
||
"DEBUG2: [cups-driverd] list_ppds(request_id=%d, limit=%d, "
|
||
"opt=\"%s\"\n", request_id, limit, opt);
|
||
|
||
/*
|
||
* See if we a PPD database file...
|
||
*/
|
||
|
||
filename[0] = '\0';
|
||
load_ppds_dat(filename, sizeof(filename), 1);
|
||
|
||
/*
|
||
* Load all PPDs in the specified directory and below...
|
||
*/
|
||
|
||
if ((cups_datadir = getenv("CUPS_DATADIR")) == NULL)
|
||
cups_datadir = CUPS_DATADIR;
|
||
|
||
Inodes = cupsArrayNew((cups_array_func_t)compare_inodes, NULL);
|
||
|
||
snprintf(model, sizeof(model), "%s/model", cups_datadir);
|
||
load_ppds(model, "", 1);
|
||
|
||
snprintf(model, sizeof(model), "%s/drv", cups_datadir);
|
||
load_ppds(model, "", 1);
|
||
|
||
#ifdef __APPLE__
|
||
/*
|
||
* Load PPDs from standard macOS locations...
|
||
*/
|
||
|
||
load_ppds("/Library/Printers",
|
||
"Library/Printers", 0);
|
||
load_ppds("/Library/Printers/PPDs/Contents/Resources",
|
||
"Library/Printers/PPDs/Contents/Resources", 0);
|
||
load_ppds("/Library/Printers/PPDs/Contents/Resources/en.lproj",
|
||
"Library/Printers/PPDs/Contents/Resources/en.lproj", 0);
|
||
load_ppds("/System/Library/Printers",
|
||
"System/Library/Printers", 0);
|
||
load_ppds("/System/Library/Printers/PPDs/Contents/Resources",
|
||
"System/Library/Printers/PPDs/Contents/Resources", 0);
|
||
load_ppds("/System/Library/Printers/PPDs/Contents/Resources/en.lproj",
|
||
"System/Library/Printers/PPDs/Contents/Resources/en.lproj", 0);
|
||
|
||
#elif defined(__linux)
|
||
/*
|
||
* Load PPDs from LSB-defined locations...
|
||
*/
|
||
|
||
if (!access("/usr/local/share/ppd", 0))
|
||
load_ppds("/usr/local/share/ppd", "lsb/local", 1);
|
||
if (!access("/usr/share/ppd", 0))
|
||
load_ppds("/usr/share/ppd", "lsb/usr", 1);
|
||
if (!access("/opt/share/ppd", 0))
|
||
load_ppds("/opt/share/ppd", "lsb/opt", 1);
|
||
#endif /* __APPLE__ */
|
||
|
||
/*
|
||
* Cull PPD files that are no longer present...
|
||
*/
|
||
|
||
for (ppd = (ppd_info_t *)cupsArrayFirst(PPDsByName);
|
||
ppd;
|
||
ppd = (ppd_info_t *)cupsArrayNext(PPDsByName))
|
||
if (!ppd->found)
|
||
{
|
||
/*
|
||
* Remove this PPD file from the list...
|
||
*/
|
||
|
||
cupsArrayRemove(PPDsByName, ppd);
|
||
cupsArrayRemove(PPDsByMakeModel, ppd);
|
||
free(ppd);
|
||
|
||
ChangedPPD = 1;
|
||
}
|
||
|
||
/*
|
||
* Write the new ppds.dat file...
|
||
*/
|
||
|
||
fprintf(stderr, "DEBUG: [cups-driverd] ChangedPPD=%d\n", ChangedPPD);
|
||
|
||
if (ChangedPPD)
|
||
{
|
||
char newname[1024]; /* New filename */
|
||
|
||
snprintf(newname, sizeof(newname), "%s.%d", filename, (int)getpid());
|
||
|
||
if ((fp = cupsFileOpen(newname, "w")) != NULL)
|
||
{
|
||
unsigned ppdsync = PPD_SYNC; /* Sync word */
|
||
|
||
cupsFileWrite(fp, (char *)&ppdsync, sizeof(ppdsync));
|
||
|
||
for (ppd = (ppd_info_t *)cupsArrayFirst(PPDsByName);
|
||
ppd;
|
||
ppd = (ppd_info_t *)cupsArrayNext(PPDsByName))
|
||
cupsFileWrite(fp, (char *)&(ppd->record), sizeof(ppd_rec_t));
|
||
|
||
cupsFileClose(fp);
|
||
|
||
if (rename(newname, filename))
|
||
fprintf(stderr, "ERROR: [cups-driverd] Unable to rename \"%s\" - %s\n",
|
||
newname, strerror(errno));
|
||
else
|
||
fprintf(stderr, "INFO: [cups-driverd] Wrote \"%s\", %d PPDs...\n",
|
||
filename, cupsArrayCount(PPDsByName));
|
||
}
|
||
else
|
||
fprintf(stderr, "ERROR: [cups-driverd] Unable to write \"%s\" - %s\n",
|
||
filename, strerror(errno));
|
||
}
|
||
else
|
||
fputs("INFO: [cups-driverd] No new or changed PPDs...\n", stderr);
|
||
|
||
/*
|
||
* Scan for dynamic PPD files...
|
||
*/
|
||
|
||
num_options = cupsParseOptions(opt, 0, &options);
|
||
exclude = cupsdCreateStringsArray(cupsGetOption("exclude-schemes",
|
||
num_options, options));
|
||
include = cupsdCreateStringsArray(cupsGetOption("include-schemes",
|
||
num_options, options));
|
||
|
||
load_drivers(include, exclude);
|
||
|
||
/*
|
||
* Add the raw driver...
|
||
*/
|
||
|
||
add_ppd("", "raw", "en", "Raw", "Raw Queue", "", "", "", 0, 0, 0,
|
||
PPD_TYPE_UNKNOWN, "raw");
|
||
|
||
/*
|
||
* Send IPP attributes...
|
||
*/
|
||
|
||
requested = cupsdCreateStringsArray(
|
||
cupsGetOption("requested-attributes", num_options,
|
||
options));
|
||
device_id = cupsGetOption("ppd-device-id", num_options, options);
|
||
language = cupsGetOption("ppd-natural-language", num_options, options);
|
||
make = cupsGetOption("ppd-make", num_options, options);
|
||
make_and_model = cupsGetOption("ppd-make-and-model", num_options, options);
|
||
model_number_str = cupsGetOption("ppd-model-number", num_options, options);
|
||
product = cupsGetOption("ppd-product", num_options, options);
|
||
psversion = cupsGetOption("ppd-psversion", num_options, options);
|
||
type_str = cupsGetOption("ppd-type", num_options, options);
|
||
|
||
if (make_and_model)
|
||
make_and_model_len = strlen(make_and_model);
|
||
else
|
||
make_and_model_len = 0;
|
||
|
||
if (product)
|
||
product_len = strlen(product);
|
||
else
|
||
product_len = 0;
|
||
|
||
if (model_number_str)
|
||
model_number = atoi(model_number_str);
|
||
else
|
||
model_number = 0;
|
||
|
||
if (type_str)
|
||
{
|
||
for (type = 0;
|
||
type < (int)(sizeof(PPDTypes) / sizeof(PPDTypes[0]));
|
||
type ++)
|
||
if (!strcmp(type_str, PPDTypes[type]))
|
||
break;
|
||
|
||
if (type >= (int)(sizeof(PPDTypes) / sizeof(PPDTypes[0])))
|
||
{
|
||
fprintf(stderr, "ERROR: [cups-driverd] Bad ppd-type=\"%s\" ignored!\n",
|
||
type_str);
|
||
type_str = NULL;
|
||
}
|
||
}
|
||
else
|
||
type = 0;
|
||
|
||
for (i = 0; i < num_options; i ++)
|
||
fprintf(stderr, "DEBUG2: [cups-driverd] %s=\"%s\"\n", options[i].name,
|
||
options[i].value);
|
||
|
||
if (!requested || cupsArrayFind(requested, (void *)"all") != NULL)
|
||
{
|
||
send_name = 1;
|
||
send_make = 1;
|
||
send_make_and_model = 1;
|
||
send_model_number = 1;
|
||
send_natural_language = 1;
|
||
send_device_id = 1;
|
||
send_product = 1;
|
||
send_psversion = 1;
|
||
send_type = 1;
|
||
}
|
||
else
|
||
{
|
||
send_name = cupsArrayFind(requested,
|
||
(void *)"ppd-name") != NULL;
|
||
send_make = cupsArrayFind(requested,
|
||
(void *)"ppd-make") != NULL;
|
||
send_make_and_model = cupsArrayFind(requested,
|
||
(void *)"ppd-make-and-model") != NULL;
|
||
send_model_number = cupsArrayFind(requested,
|
||
(void *)"ppd-model-number") != NULL;
|
||
send_natural_language = cupsArrayFind(requested,
|
||
(void *)"ppd-natural-language") != NULL;
|
||
send_device_id = cupsArrayFind(requested,
|
||
(void *)"ppd-device-id") != NULL;
|
||
send_product = cupsArrayFind(requested,
|
||
(void *)"ppd-product") != NULL;
|
||
send_psversion = cupsArrayFind(requested,
|
||
(void *)"ppd-psversion") != NULL;
|
||
send_type = cupsArrayFind(requested,
|
||
(void *)"ppd-type") != NULL;
|
||
}
|
||
|
||
/*
|
||
* Send the content type header to the scheduler; request_id can only be
|
||
* 0 when run manually since the scheduler enforces the IPP requirement for
|
||
* a request ID from 1 to 2^31-1...
|
||
*/
|
||
|
||
if (request_id > 0)
|
||
puts("Content-Type: application/ipp\n");
|
||
|
||
sent_header = 0;
|
||
|
||
if (limit <= 0 || limit > cupsArrayCount(PPDsByMakeModel))
|
||
count = cupsArrayCount(PPDsByMakeModel);
|
||
else
|
||
count = limit;
|
||
|
||
if (device_id || language || make || make_and_model || model_number_str ||
|
||
product)
|
||
{
|
||
matches = cupsArrayNew((cups_array_func_t)compare_matches, NULL);
|
||
|
||
if (device_id)
|
||
device_id_re = regex_device_id(device_id);
|
||
else
|
||
device_id_re = NULL;
|
||
|
||
if (make_and_model)
|
||
make_and_model_re = regex_string(make_and_model);
|
||
else
|
||
make_and_model_re = NULL;
|
||
|
||
for (ppd = (ppd_info_t *)cupsArrayFirst(PPDsByMakeModel);
|
||
ppd;
|
||
ppd = (ppd_info_t *)cupsArrayNext(PPDsByMakeModel))
|
||
{
|
||
/*
|
||
* Filter PPDs based on make, model, product, language, model number,
|
||
* and/or device ID using the "matches" score value. An exact match
|
||
* for product, make-and-model, or device-id adds 3 to the score.
|
||
* Partial matches for make-and-model yield 1 or 2 points, and matches
|
||
* for the make and language add a single point. Results are then sorted
|
||
* by score, highest score first.
|
||
*/
|
||
|
||
if (ppd->record.type < PPD_TYPE_POSTSCRIPT ||
|
||
ppd->record.type >= PPD_TYPE_DRV)
|
||
continue;
|
||
|
||
if (cupsArrayFind(exclude, ppd->record.scheme) ||
|
||
(include && !cupsArrayFind(include, ppd->record.scheme)))
|
||
continue;
|
||
|
||
ppd->matches = 0;
|
||
|
||
if (device_id_re &&
|
||
!regexec(device_id_re, ppd->record.device_id,
|
||
(size_t)(sizeof(re_matches) / sizeof(re_matches[0])),
|
||
re_matches, 0))
|
||
{
|
||
/*
|
||
* Add the number of matching values from the device ID - it will be
|
||
* at least 2 (manufacturer and model), and as much as 3 (command set).
|
||
*/
|
||
|
||
for (i = 1; i < (int)(sizeof(re_matches) / sizeof(re_matches[0])); i ++)
|
||
if (re_matches[i].rm_so >= 0)
|
||
ppd->matches ++;
|
||
}
|
||
|
||
if (language)
|
||
{
|
||
for (i = 0; i < PPD_MAX_LANG; i ++)
|
||
if (!ppd->record.languages[i][0])
|
||
break;
|
||
else if (!strcmp(ppd->record.languages[i], language))
|
||
{
|
||
ppd->matches ++;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (make && !_cups_strcasecmp(ppd->record.make, make))
|
||
ppd->matches ++;
|
||
|
||
if (make_and_model_re &&
|
||
!regexec(make_and_model_re, ppd->record.make_and_model,
|
||
(size_t)(sizeof(re_matches) / sizeof(re_matches[0])),
|
||
re_matches, 0))
|
||
{
|
||
// See how much of the make-and-model string we matched...
|
||
if (re_matches[0].rm_so == 0)
|
||
{
|
||
if ((size_t)re_matches[0].rm_eo == make_and_model_len)
|
||
ppd->matches += 3; // Exact match
|
||
else
|
||
ppd->matches += 2; // Prefix match
|
||
}
|
||
else
|
||
ppd->matches ++; // Infix match
|
||
}
|
||
|
||
if (model_number_str && ppd->record.model_number == model_number)
|
||
ppd->matches ++;
|
||
|
||
if (product)
|
||
{
|
||
for (i = 0; i < PPD_MAX_PROD; i ++)
|
||
if (!ppd->record.products[i][0])
|
||
break;
|
||
else if (!_cups_strcasecmp(ppd->record.products[i], product))
|
||
{
|
||
ppd->matches += 3;
|
||
break;
|
||
}
|
||
else if (!_cups_strncasecmp(ppd->record.products[i], product,
|
||
product_len))
|
||
{
|
||
ppd->matches += 2;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (psversion)
|
||
{
|
||
for (i = 0; i < PPD_MAX_VERS; i ++)
|
||
if (!ppd->record.psversions[i][0])
|
||
break;
|
||
else if (!_cups_strcasecmp(ppd->record.psversions[i], psversion))
|
||
{
|
||
ppd->matches ++;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (type_str && ppd->record.type == type)
|
||
ppd->matches ++;
|
||
|
||
if (ppd->matches)
|
||
{
|
||
fprintf(stderr, "DEBUG2: [cups-driverd] %s matches with score %d!\n",
|
||
ppd->record.name, ppd->matches);
|
||
cupsArrayAdd(matches, ppd);
|
||
}
|
||
}
|
||
}
|
||
else if (include || exclude)
|
||
{
|
||
matches = cupsArrayNew((cups_array_func_t)compare_ppds, NULL);
|
||
|
||
for (ppd = (ppd_info_t *)cupsArrayFirst(PPDsByMakeModel);
|
||
ppd;
|
||
ppd = (ppd_info_t *)cupsArrayNext(PPDsByMakeModel))
|
||
{
|
||
/*
|
||
* Filter PPDs based on the include/exclude lists.
|
||
*/
|
||
|
||
if (ppd->record.type < PPD_TYPE_POSTSCRIPT ||
|
||
ppd->record.type >= PPD_TYPE_DRV)
|
||
continue;
|
||
|
||
if (cupsArrayFind(exclude, ppd->record.scheme) ||
|
||
(include && !cupsArrayFind(include, ppd->record.scheme)))
|
||
continue;
|
||
|
||
cupsArrayAdd(matches, ppd);
|
||
}
|
||
}
|
||
else
|
||
matches = PPDsByMakeModel;
|
||
|
||
for (ppd = (ppd_info_t *)cupsArrayFirst(matches);
|
||
count > 0 && ppd;
|
||
ppd = (ppd_info_t *)cupsArrayNext(matches))
|
||
{
|
||
/*
|
||
* Skip invalid PPDs...
|
||
*/
|
||
|
||
if (ppd->record.type < PPD_TYPE_POSTSCRIPT ||
|
||
ppd->record.type >= PPD_TYPE_DRV)
|
||
continue;
|
||
|
||
/*
|
||
* Send this PPD...
|
||
*/
|
||
|
||
if (!sent_header)
|
||
{
|
||
sent_header = 1;
|
||
|
||
if (request_id)
|
||
{
|
||
cupsdSendIPPHeader(IPP_OK, request_id);
|
||
cupsdSendIPPGroup(IPP_TAG_OPERATION);
|
||
cupsdSendIPPString(IPP_TAG_CHARSET, "attributes-charset", "utf-8");
|
||
cupsdSendIPPString(IPP_TAG_LANGUAGE, "attributes-natural-language",
|
||
"en-US");
|
||
}
|
||
}
|
||
|
||
fprintf(stderr, "DEBUG2: [cups-driverd] Sending %s (%s)...\n",
|
||
ppd->record.name, ppd->record.make_and_model);
|
||
|
||
count --;
|
||
|
||
if (request_id)
|
||
{
|
||
cupsdSendIPPGroup(IPP_TAG_PRINTER);
|
||
|
||
if (send_name)
|
||
cupsdSendIPPString(IPP_TAG_NAME, "ppd-name", ppd->record.name);
|
||
|
||
if (send_natural_language)
|
||
{
|
||
cupsdSendIPPString(IPP_TAG_LANGUAGE, "ppd-natural-language",
|
||
ppd->record.languages[0]);
|
||
|
||
for (i = 1; i < PPD_MAX_LANG && ppd->record.languages[i][0]; i ++)
|
||
cupsdSendIPPString(IPP_TAG_LANGUAGE, "", ppd->record.languages[i]);
|
||
}
|
||
|
||
if (send_make)
|
||
cupsdSendIPPString(IPP_TAG_TEXT, "ppd-make", ppd->record.make);
|
||
|
||
if (send_make_and_model)
|
||
cupsdSendIPPString(IPP_TAG_TEXT, "ppd-make-and-model",
|
||
ppd->record.make_and_model);
|
||
|
||
if (send_device_id)
|
||
cupsdSendIPPString(IPP_TAG_TEXT, "ppd-device-id",
|
||
ppd->record.device_id);
|
||
|
||
if (send_product)
|
||
{
|
||
cupsdSendIPPString(IPP_TAG_TEXT, "ppd-product",
|
||
ppd->record.products[0]);
|
||
|
||
for (i = 1; i < PPD_MAX_PROD && ppd->record.products[i][0]; i ++)
|
||
cupsdSendIPPString(IPP_TAG_TEXT, "", ppd->record.products[i]);
|
||
}
|
||
|
||
if (send_psversion)
|
||
{
|
||
cupsdSendIPPString(IPP_TAG_TEXT, "ppd-psversion",
|
||
ppd->record.psversions[0]);
|
||
|
||
for (i = 1; i < PPD_MAX_VERS && ppd->record.psversions[i][0]; i ++)
|
||
cupsdSendIPPString(IPP_TAG_TEXT, "", ppd->record.psversions[i]);
|
||
}
|
||
|
||
if (send_type)
|
||
{
|
||
if (ppd->record.type < PPD_TYPE_POSTSCRIPT || ppd->record.type > PPD_TYPE_ARCHIVE)
|
||
{
|
||
/*
|
||
* This cache file is corrupted, remove it!
|
||
*/
|
||
|
||
unlink(filename);
|
||
|
||
cupsdSendIPPString(IPP_TAG_KEYWORD, "ppd-type", PPDTypes[PPD_TYPE_UNKNOWN]);
|
||
}
|
||
else
|
||
cupsdSendIPPString(IPP_TAG_KEYWORD, "ppd-type", PPDTypes[ppd->record.type]);
|
||
}
|
||
|
||
if (send_model_number)
|
||
cupsdSendIPPInteger(IPP_TAG_INTEGER, "ppd-model-number",
|
||
ppd->record.model_number);
|
||
}
|
||
else
|
||
printf("%s (%s)\n", ppd->record.name, ppd->record.make_and_model);
|
||
|
||
/*
|
||
* If we have only requested the ppd-make attribute, then skip
|
||
* the remaining PPDs with this make...
|
||
*/
|
||
|
||
if (cupsArrayFind(requested, (void *)"ppd-make") &&
|
||
cupsArrayCount(requested) == 1)
|
||
{
|
||
const char *this_make; /* This ppd-make */
|
||
|
||
|
||
for (this_make = ppd->record.make,
|
||
ppd = (ppd_info_t *)cupsArrayNext(matches);
|
||
ppd;
|
||
ppd = (ppd_info_t *)cupsArrayNext(matches))
|
||
if (_cups_strcasecmp(this_make, ppd->record.make))
|
||
break;
|
||
|
||
cupsArrayPrev(matches);
|
||
}
|
||
}
|
||
|
||
if (!sent_header && request_id)
|
||
{
|
||
cupsdSendIPPHeader(IPP_NOT_FOUND, request_id);
|
||
cupsdSendIPPGroup(IPP_TAG_OPERATION);
|
||
cupsdSendIPPString(IPP_TAG_CHARSET, "attributes-charset", "utf-8");
|
||
cupsdSendIPPString(IPP_TAG_LANGUAGE, "attributes-natural-language", "en-US");
|
||
}
|
||
|
||
if (request_id)
|
||
cupsdSendIPPTrailer();
|
||
|
||
exit(0);
|
||
}
|
||
|
||
|
||
/*
|
||
* 'load_drv()' - Load the PPDs from a driver information file.
|
||
*/
|
||
|
||
static int /* O - 1 on success, 0 on failure */
|
||
load_drv(const char *filename, /* I - Actual filename */
|
||
const char *name, /* I - Name to the rest of the world */
|
||
cups_file_t *fp, /* I - File to read from */
|
||
time_t mtime, /* I - Mod time of driver info file */
|
||
off_t size) /* I - Size of driver info file */
|
||
{
|
||
ppdcSource *src; // Driver information file
|
||
ppdcDriver *d; // Current driver
|
||
ppdcAttr *device_id, // 1284DeviceID attribute
|
||
*product, // Current product value
|
||
*ps_version, // PSVersion attribute
|
||
*cups_fax, // cupsFax attribute
|
||
*nick_name; // NickName attribute
|
||
ppdcFilter *filter; // Current filter
|
||
ppd_info_t *ppd; // Current PPD
|
||
int products_found; // Number of products found
|
||
char uri[1024], // Driver URI
|
||
make_model[1024]; // Make and model
|
||
int type; // Driver type
|
||
|
||
|
||
/*
|
||
* Load the driver info file...
|
||
*/
|
||
|
||
src = new ppdcSource(filename, fp);
|
||
|
||
if (src->drivers->count == 0)
|
||
{
|
||
fprintf(stderr,
|
||
"ERROR: [cups-driverd] Bad driver information file \"%s\"!\n",
|
||
filename);
|
||
src->release();
|
||
return (0);
|
||
}
|
||
|
||
/*
|
||
* Add a dummy entry for the file...
|
||
*/
|
||
|
||
add_ppd(name, name, "", "", "", "", "", "", mtime, (size_t)size, 0, PPD_TYPE_DRV, "drv");
|
||
ChangedPPD = 1;
|
||
|
||
/*
|
||
* Then the drivers in the file...
|
||
*/
|
||
|
||
for (d = (ppdcDriver *)src->drivers->first();
|
||
d;
|
||
d = (ppdcDriver *)src->drivers->next())
|
||
{
|
||
httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "drv", "", "", 0,
|
||
"/%s/%s", name,
|
||
d->file_name ? d->file_name->value :
|
||
d->pc_file_name->value);
|
||
|
||
device_id = d->find_attr("1284DeviceID", NULL);
|
||
ps_version = d->find_attr("PSVersion", NULL);
|
||
nick_name = d->find_attr("NickName", NULL);
|
||
|
||
if (nick_name)
|
||
strlcpy(make_model, nick_name->value->value, sizeof(make_model));
|
||
else if (_cups_strncasecmp(d->model_name->value, d->manufacturer->value,
|
||
strlen(d->manufacturer->value)))
|
||
snprintf(make_model, sizeof(make_model), "%s %s, %s",
|
||
d->manufacturer->value, d->model_name->value,
|
||
d->version->value);
|
||
else
|
||
snprintf(make_model, sizeof(make_model), "%s, %s", d->model_name->value,
|
||
d->version->value);
|
||
|
||
if ((cups_fax = d->find_attr("cupsFax", NULL)) != NULL &&
|
||
!_cups_strcasecmp(cups_fax->value->value, "true"))
|
||
type = PPD_TYPE_FAX;
|
||
else if (d->type == PPDC_DRIVER_PS)
|
||
type = PPD_TYPE_POSTSCRIPT;
|
||
else if (d->type != PPDC_DRIVER_CUSTOM)
|
||
type = PPD_TYPE_RASTER;
|
||
else
|
||
{
|
||
for (filter = (ppdcFilter *)d->filters->first(),
|
||
type = PPD_TYPE_POSTSCRIPT;
|
||
filter;
|
||
filter = (ppdcFilter *)d->filters->next())
|
||
if (_cups_strcasecmp(filter->mime_type->value, "application/vnd.cups-raster"))
|
||
type = PPD_TYPE_RASTER;
|
||
else if (_cups_strcasecmp(filter->mime_type->value,
|
||
"application/vnd.cups-pdf"))
|
||
type = PPD_TYPE_PDF;
|
||
}
|
||
|
||
for (product = (ppdcAttr *)d->attrs->first(), products_found = 0,
|
||
ppd = NULL;
|
||
product;
|
||
product = (ppdcAttr *)d->attrs->next())
|
||
if (!strcmp(product->name->value, "Product"))
|
||
{
|
||
if (!products_found)
|
||
ppd = add_ppd(name, uri, "en", d->manufacturer->value, make_model, device_id ? device_id->value->value : "", product->value->value,
|
||
ps_version ? ps_version->value->value : "(3010) 0", mtime, (size_t)size, d->model_number, type, "drv");
|
||
else if (products_found < PPD_MAX_PROD)
|
||
strlcpy(ppd->record.products[products_found], product->value->value, sizeof(ppd->record.products[0]));
|
||
else
|
||
break;
|
||
|
||
products_found ++;
|
||
}
|
||
|
||
if (!products_found)
|
||
add_ppd(name, uri, "en", d->manufacturer->value, make_model, device_id ? device_id->value->value : "", d->model_name->value, ps_version ? ps_version->value->value : "(3010) 0", mtime, (size_t)size, d->model_number, type, "drv");
|
||
}
|
||
|
||
src->release();
|
||
|
||
return (1);
|
||
}
|
||
|
||
|
||
/*
|
||
* 'load_drivers()' - Load driver-generated PPD files.
|
||
*/
|
||
|
||
static int /* O - 1 on success, 0 on failure */
|
||
load_drivers(cups_array_t *include, /* I - Drivers to include */
|
||
cups_array_t *exclude) /* I - Drivers to exclude */
|
||
{
|
||
int i; /* Looping var */
|
||
char *start, /* Start of value */
|
||
*ptr; /* Pointer into string */
|
||
const char *server_bin, /* CUPS_SERVERBIN env variable */
|
||
*scheme, /* Scheme for this driver */
|
||
*scheme_end; /* Pointer to end of scheme */
|
||
char drivers[1024]; /* Location of driver programs */
|
||
int pid; /* Process ID for driver program */
|
||
cups_file_t *fp; /* Pipe to driver program */
|
||
cups_dir_t *dir; /* Directory pointer */
|
||
cups_dentry_t *dent; /* Directory entry */
|
||
char *argv[3], /* Arguments for command */
|
||
filename[1024], /* Name of driver */
|
||
line[2048], /* Line from driver */
|
||
name[256], /* ppd-name */
|
||
make[128], /* ppd-make */
|
||
make_and_model[128], /* ppd-make-and-model */
|
||
device_id[256], /* ppd-device-id */
|
||
languages[128], /* ppd-natural-language */
|
||
product[128], /* ppd-product */
|
||
psversion[128], /* ppd-psversion */
|
||
type_str[128]; /* ppd-type */
|
||
int type; /* PPD type */
|
||
ppd_info_t *ppd; /* Newly added PPD */
|
||
|
||
|
||
/*
|
||
* Try opening the driver directory...
|
||
*/
|
||
|
||
if ((server_bin = getenv("CUPS_SERVERBIN")) == NULL)
|
||
server_bin = CUPS_SERVERBIN;
|
||
|
||
snprintf(drivers, sizeof(drivers), "%s/driver", server_bin);
|
||
|
||
if ((dir = cupsDirOpen(drivers)) == NULL)
|
||
{
|
||
fprintf(stderr, "ERROR: [cups-driverd] Unable to open driver directory "
|
||
"\"%s\": %s\n",
|
||
drivers, strerror(errno));
|
||
return (0);
|
||
}
|
||
|
||
/*
|
||
* Loop through all of the device drivers...
|
||
*/
|
||
|
||
argv[1] = (char *)"list";
|
||
argv[2] = NULL;
|
||
|
||
while ((dent = cupsDirRead(dir)) != NULL)
|
||
{
|
||
/*
|
||
* Only look at executable files...
|
||
*/
|
||
|
||
if (!(dent->fileinfo.st_mode & 0111) || !S_ISREG(dent->fileinfo.st_mode))
|
||
continue;
|
||
|
||
/*
|
||
* Include/exclude specific drivers...
|
||
*/
|
||
|
||
if (exclude)
|
||
{
|
||
/*
|
||
* Look for "scheme" or "scheme*" (prefix match), and skip any matches.
|
||
*/
|
||
|
||
for (scheme = (char *)cupsArrayFirst(exclude);
|
||
scheme;
|
||
scheme = (char *)cupsArrayNext(exclude))
|
||
{
|
||
fprintf(stderr, "DEBUG: [cups-driverd] Exclude \"%s\" with \"%s\"?\n",
|
||
dent->filename, scheme);
|
||
scheme_end = scheme + strlen(scheme) - 1;
|
||
|
||
if ((scheme_end > scheme && *scheme_end == '*' &&
|
||
!strncmp(scheme, dent->filename, (size_t)(scheme_end - scheme))) ||
|
||
!strcmp(scheme, dent->filename))
|
||
{
|
||
fputs("DEBUG: [cups-driverd] Yes, exclude!\n", stderr);
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (scheme)
|
||
continue;
|
||
}
|
||
|
||
if (include)
|
||
{
|
||
/*
|
||
* Look for "scheme" or "scheme*" (prefix match), and skip any non-matches.
|
||
*/
|
||
|
||
for (scheme = (char *)cupsArrayFirst(include);
|
||
scheme;
|
||
scheme = (char *)cupsArrayNext(include))
|
||
{
|
||
fprintf(stderr, "DEBUG: [cups-driverd] Include \"%s\" with \"%s\"?\n",
|
||
dent->filename, scheme);
|
||
scheme_end = scheme + strlen(scheme) - 1;
|
||
|
||
if ((scheme_end > scheme && *scheme_end == '*' &&
|
||
!strncmp(scheme, dent->filename, (size_t)(scheme_end - scheme))) ||
|
||
!strcmp(scheme, dent->filename))
|
||
{
|
||
fputs("DEBUG: [cups-driverd] Yes, include!\n", stderr);
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (!scheme)
|
||
continue;
|
||
}
|
||
else
|
||
scheme = dent->filename;
|
||
|
||
/*
|
||
* Run the driver with no arguments and collect the output...
|
||
*/
|
||
|
||
snprintf(filename, sizeof(filename), "%s/%s", drivers, dent->filename);
|
||
|
||
if (_cupsFileCheck(filename, _CUPS_FILE_CHECK_PROGRAM, !geteuid(),
|
||
_cupsFileCheckFilter, NULL))
|
||
continue;
|
||
|
||
argv[0] = dent->filename;
|
||
|
||
if ((fp = cupsdPipeCommand(&pid, filename, argv, 0)) != NULL)
|
||
{
|
||
while (cupsFileGets(fp, line, sizeof(line)))
|
||
{
|
||
/*
|
||
* Each line is of the form:
|
||
*
|
||
* "ppd-name" ppd-natural-language "ppd-make" "ppd-make-and-model" \
|
||
* "ppd-device-id" "ppd-product" "ppd-psversion"
|
||
*/
|
||
|
||
device_id[0] = '\0';
|
||
product[0] = '\0';
|
||
psversion[0] = '\0';
|
||
strlcpy(type_str, "postscript", sizeof(type_str));
|
||
|
||
if (sscanf(line, "\"%255[^\"]\"%127s%*[ \t]\"%127[^\"]\""
|
||
"%*[ \t]\"%127[^\"]\"%*[ \t]\"%255[^\"]\""
|
||
"%*[ \t]\"%127[^\"]\"%*[ \t]\"%127[^\"]\""
|
||
"%*[ \t]\"%127[^\"]\"",
|
||
name, languages, make, make_and_model,
|
||
device_id, product, psversion, type_str) < 4)
|
||
{
|
||
/*
|
||
* Bad format; strip trailing newline and write an error message.
|
||
*/
|
||
|
||
if (line[strlen(line) - 1] == '\n')
|
||
line[strlen(line) - 1] = '\0';
|
||
|
||
fprintf(stderr, "ERROR: [cups-driverd] Bad line from \"%s\": %s\n",
|
||
dent->filename, line);
|
||
break;
|
||
}
|
||
else
|
||
{
|
||
/*
|
||
* Add the device to the array of available devices...
|
||
*/
|
||
|
||
if ((start = strchr(languages, ',')) != NULL)
|
||
*start++ = '\0';
|
||
|
||
for (type = 0;
|
||
type < (int)(sizeof(PPDTypes) / sizeof(PPDTypes[0]));
|
||
type ++)
|
||
if (!strcmp(type_str, PPDTypes[type]))
|
||
break;
|
||
|
||
if (type >= (int)(sizeof(PPDTypes) / sizeof(PPDTypes[0])))
|
||
{
|
||
fprintf(stderr,
|
||
"ERROR: [cups-driverd] Bad ppd-type \"%s\" ignored!\n",
|
||
type_str);
|
||
type = PPD_TYPE_UNKNOWN;
|
||
}
|
||
|
||
ppd = add_ppd(filename, name, languages, make, make_and_model,
|
||
device_id, product, psversion, 0, 0, 0, type, scheme);
|
||
|
||
if (!ppd)
|
||
{
|
||
cupsDirClose(dir);
|
||
cupsFileClose(fp);
|
||
return (0);
|
||
}
|
||
|
||
if (start && *start)
|
||
{
|
||
for (i = 1; i < PPD_MAX_LANG && *start; i ++)
|
||
{
|
||
if ((ptr = strchr(start, ',')) != NULL)
|
||
*ptr++ = '\0';
|
||
else
|
||
ptr = start + strlen(start);
|
||
|
||
strlcpy(ppd->record.languages[i], start,
|
||
sizeof(ppd->record.languages[0]));
|
||
|
||
start = ptr;
|
||
}
|
||
}
|
||
|
||
fprintf(stderr, "DEBUG2: [cups-driverd] Added dynamic PPD \"%s\"...\n",
|
||
name);
|
||
}
|
||
}
|
||
|
||
cupsFileClose(fp);
|
||
}
|
||
else
|
||
fprintf(stderr, "WARNING: [cups-driverd] Unable to execute \"%s\": %s\n",
|
||
filename, strerror(errno));
|
||
}
|
||
|
||
cupsDirClose(dir);
|
||
|
||
return (1);
|
||
}
|
||
|
||
|
||
/*
|
||
* 'load_ppd()' - Load a PPD file.
|
||
*/
|
||
|
||
static void
|
||
load_ppd(const char *filename, /* I - Real filename */
|
||
const char *name, /* I - Virtual filename */
|
||
const char *scheme, /* I - PPD scheme */
|
||
struct stat *fileinfo, /* I - File information */
|
||
ppd_info_t *ppd, /* I - Existing PPD file or NULL */
|
||
cups_file_t *fp, /* I - File to read from */
|
||
off_t end) /* I - End of file position or 0 */
|
||
{
|
||
int i; /* Looping var */
|
||
char line[256], /* Line from file */
|
||
*ptr, /* Pointer into line */
|
||
lang_version[64], /* PPD LanguageVersion */
|
||
lang_encoding[64], /* PPD LanguageEncoding */
|
||
country[64], /* Country code */
|
||
manufacturer[256], /* Manufacturer */
|
||
make_model[256], /* Make and Model */
|
||
model_name[256], /* ModelName */
|
||
nick_name[256], /* NickName */
|
||
device_id[256], /* 1284DeviceID */
|
||
product[256], /* Product */
|
||
psversion[256], /* PSVersion */
|
||
temp[512]; /* Temporary make and model */
|
||
int install_group, /* In the installable options group? */
|
||
model_number, /* cupsModelNumber */
|
||
type; /* ppd-type */
|
||
cups_array_t *products, /* Product array */
|
||
*psversions, /* PSVersion array */
|
||
*cups_languages; /* cupsLanguages array */
|
||
int new_ppd; /* Is this a new PPD? */
|
||
struct /* LanguageVersion translation table */
|
||
{
|
||
const char *version, /* LanguageVersion string */
|
||
*language; /* Language code */
|
||
} languages[] =
|
||
{
|
||
{ "chinese", "zh" },
|
||
{ "czech", "cs" },
|
||
{ "danish", "da" },
|
||
{ "dutch", "nl" },
|
||
{ "english", "en" },
|
||
{ "finnish", "fi" },
|
||
{ "french", "fr" },
|
||
{ "german", "de" },
|
||
{ "greek", "el" },
|
||
{ "hungarian", "hu" },
|
||
{ "italian", "it" },
|
||
{ "japanese", "ja" },
|
||
{ "korean", "ko" },
|
||
{ "norwegian", "no" },
|
||
{ "polish", "pl" },
|
||
{ "portuguese", "pt" },
|
||
{ "russian", "ru" },
|
||
{ "simplified chinese", "zh_CN" },
|
||
{ "slovak", "sk" },
|
||
{ "spanish", "es" },
|
||
{ "swedish", "sv" },
|
||
{ "traditional chinese", "zh_TW" },
|
||
{ "turkish", "tr" }
|
||
};
|
||
|
||
|
||
/*
|
||
* Now read until we get the required fields...
|
||
*/
|
||
|
||
cups_languages = cupsArrayNew(NULL, NULL);
|
||
products = cupsArrayNew(NULL, NULL);
|
||
psversions = cupsArrayNew(NULL, NULL);
|
||
|
||
model_name[0] = '\0';
|
||
nick_name[0] = '\0';
|
||
manufacturer[0] = '\0';
|
||
device_id[0] = '\0';
|
||
lang_encoding[0] = '\0';
|
||
strlcpy(lang_version, "en", sizeof(lang_version));
|
||
model_number = 0;
|
||
install_group = 0;
|
||
type = PPD_TYPE_POSTSCRIPT;
|
||
|
||
while ((end == 0 || cupsFileTell(fp) < end) &&
|
||
cupsFileGets(fp, line, sizeof(line)))
|
||
{
|
||
if (!strncmp(line, "*Manufacturer:", 14))
|
||
sscanf(line, "%*[^\"]\"%255[^\"]", manufacturer);
|
||
else if (!strncmp(line, "*ModelName:", 11))
|
||
sscanf(line, "%*[^\"]\"%127[^\"]", model_name);
|
||
else if (!strncmp(line, "*LanguageEncoding:", 18))
|
||
sscanf(line, "%*[^:]:%63s", lang_encoding);
|
||
else if (!strncmp(line, "*LanguageVersion:", 17))
|
||
sscanf(line, "%*[^:]:%63s", lang_version);
|
||
else if (!strncmp(line, "*NickName:", 10))
|
||
sscanf(line, "%*[^\"]\"%255[^\"]", nick_name);
|
||
else if (!_cups_strncasecmp(line, "*1284DeviceID:", 14))
|
||
{
|
||
sscanf(line, "%*[^\"]\"%255[^\"]", device_id);
|
||
|
||
// Make sure device ID ends with a semicolon...
|
||
if (device_id[0] && device_id[strlen(device_id) - 1] != ';')
|
||
strlcat(device_id, ";", sizeof(device_id));
|
||
}
|
||
else if (!strncmp(line, "*Product:", 9))
|
||
{
|
||
if (sscanf(line, "%*[^\"]\"(%255[^\"]", product) == 1)
|
||
{
|
||
/*
|
||
* Make sure the value ends with a right parenthesis - can't stop at
|
||
* the first right paren since the product name may contain escaped
|
||
* parenthesis...
|
||
*/
|
||
|
||
ptr = product + strlen(product) - 1;
|
||
if (ptr > product && *ptr == ')')
|
||
{
|
||
/*
|
||
* Yes, ends with a parenthesis, so remove it from the end and
|
||
* add the product to the list...
|
||
*/
|
||
|
||
*ptr = '\0';
|
||
cupsArrayAdd(products, strdup(product));
|
||
}
|
||
}
|
||
}
|
||
else if (!strncmp(line, "*PSVersion:", 11))
|
||
{
|
||
sscanf(line, "%*[^\"]\"%255[^\"]", psversion);
|
||
cupsArrayAdd(psversions, strdup(psversion));
|
||
}
|
||
else if (!strncmp(line, "*cupsLanguages:", 15))
|
||
{
|
||
char *start; /* Start of language */
|
||
|
||
|
||
for (start = line + 15; *start && isspace(*start & 255); start ++);
|
||
|
||
if (*start++ == '\"')
|
||
{
|
||
while (*start)
|
||
{
|
||
for (ptr = start + 1;
|
||
*ptr && *ptr != '\"' && !isspace(*ptr & 255);
|
||
ptr ++);
|
||
|
||
if (*ptr)
|
||
{
|
||
*ptr++ = '\0';
|
||
|
||
while (isspace(*ptr & 255))
|
||
*ptr++ = '\0';
|
||
}
|
||
|
||
cupsArrayAdd(cups_languages, strdup(start));
|
||
start = ptr;
|
||
}
|
||
}
|
||
}
|
||
else if (!strncmp(line, "*cupsFax:", 9))
|
||
{
|
||
for (ptr = line + 9; isspace(*ptr & 255); ptr ++);
|
||
|
||
if (!_cups_strncasecmp(ptr, "true", 4))
|
||
type = PPD_TYPE_FAX;
|
||
}
|
||
else if ((!strncmp(line, "*cupsFilter:", 12) || !strncmp(line, "*cupsFilter2:", 13)) && type == PPD_TYPE_POSTSCRIPT)
|
||
{
|
||
if (strstr(line + 12, "application/vnd.cups-raster"))
|
||
type = PPD_TYPE_RASTER;
|
||
else if (strstr(line + 12, "application/vnd.cups-pdf"))
|
||
type = PPD_TYPE_PDF;
|
||
}
|
||
else if (!strncmp(line, "*cupsModelNumber:", 17))
|
||
sscanf(line, "*cupsModelNumber:%d", &model_number);
|
||
else if (!strncmp(line, "*OpenGroup: Installable", 23))
|
||
install_group = 1;
|
||
else if (!strncmp(line, "*CloseGroup:", 12))
|
||
install_group = 0;
|
||
else if (!strncmp(line, "*OpenUI", 7))
|
||
{
|
||
/*
|
||
* Stop early if we have a NickName or ModelName attributes
|
||
* before the first non-installable OpenUI...
|
||
*/
|
||
|
||
if (!install_group && (model_name[0] || nick_name[0]) &&
|
||
cupsArrayCount(products) > 0 && cupsArrayCount(psversions) > 0)
|
||
break;
|
||
}
|
||
}
|
||
|
||
/*
|
||
* See if we got all of the required info...
|
||
*/
|
||
|
||
if (nick_name[0])
|
||
cupsCharsetToUTF8((cups_utf8_t *)make_model, nick_name,
|
||
sizeof(make_model), _ppdGetEncoding(lang_encoding));
|
||
else
|
||
strlcpy(make_model, model_name, sizeof(make_model));
|
||
|
||
while (isspace(make_model[0] & 255))
|
||
_cups_strcpy(make_model, make_model + 1);
|
||
|
||
if (!make_model[0] || cupsArrayCount(products) == 0 ||
|
||
cupsArrayCount(psversions) == 0)
|
||
{
|
||
/*
|
||
* We don't have all the info needed, so skip this file...
|
||
*/
|
||
|
||
if (!make_model[0])
|
||
fprintf(stderr, "WARNING: Missing NickName and ModelName in %s!\n",
|
||
filename);
|
||
|
||
if (cupsArrayCount(products) == 0)
|
||
fprintf(stderr, "WARNING: Missing Product in %s!\n", filename);
|
||
|
||
if (cupsArrayCount(psversions) == 0)
|
||
fprintf(stderr, "WARNING: Missing PSVersion in %s!\n", filename);
|
||
|
||
free_array(products);
|
||
free_array(psversions);
|
||
free_array(cups_languages);
|
||
|
||
return;
|
||
}
|
||
|
||
if (model_name[0])
|
||
cupsArrayAdd(products, strdup(model_name));
|
||
|
||
/*
|
||
* Normalize the make and model string...
|
||
*/
|
||
|
||
while (isspace(manufacturer[0] & 255))
|
||
_cups_strcpy(manufacturer, manufacturer + 1);
|
||
|
||
if (!_cups_strncasecmp(make_model, manufacturer, strlen(manufacturer)))
|
||
strlcpy(temp, make_model, sizeof(temp));
|
||
else
|
||
snprintf(temp, sizeof(temp), "%s %s", manufacturer, make_model);
|
||
|
||
_ppdNormalizeMakeAndModel(temp, make_model, sizeof(make_model));
|
||
|
||
/*
|
||
* See if we got a manufacturer...
|
||
*/
|
||
|
||
if (!manufacturer[0] || !strcmp(manufacturer, "ESP"))
|
||
{
|
||
/*
|
||
* Nope, copy the first part of the make and model then...
|
||
*/
|
||
|
||
strlcpy(manufacturer, make_model, sizeof(manufacturer));
|
||
|
||
/*
|
||
* Truncate at the first space, dash, or slash, or make the
|
||
* manufacturer "Other"...
|
||
*/
|
||
|
||
for (ptr = manufacturer; *ptr; ptr ++)
|
||
if (*ptr == ' ' || *ptr == '-' || *ptr == '/')
|
||
break;
|
||
|
||
if (*ptr && ptr > manufacturer)
|
||
*ptr = '\0';
|
||
else
|
||
strlcpy(manufacturer, "Other", sizeof(manufacturer));
|
||
}
|
||
else if (!_cups_strncasecmp(manufacturer, "LHAG", 4) ||
|
||
!_cups_strncasecmp(manufacturer, "linotype", 8))
|
||
strlcpy(manufacturer, "LHAG", sizeof(manufacturer));
|
||
else if (!_cups_strncasecmp(manufacturer, "Hewlett", 7))
|
||
strlcpy(manufacturer, "HP", sizeof(manufacturer));
|
||
|
||
/*
|
||
* Fix the lang_version as needed...
|
||
*/
|
||
|
||
if ((ptr = strchr(lang_version, '-')) != NULL)
|
||
*ptr++ = '\0';
|
||
else if ((ptr = strchr(lang_version, '_')) != NULL)
|
||
*ptr++ = '\0';
|
||
|
||
if (ptr)
|
||
{
|
||
/*
|
||
* Setup the country suffix...
|
||
*/
|
||
|
||
country[0] = '_';
|
||
_cups_strcpy(country + 1, ptr);
|
||
}
|
||
else
|
||
{
|
||
/*
|
||
* No country suffix...
|
||
*/
|
||
|
||
country[0] = '\0';
|
||
}
|
||
|
||
for (i = 0; i < (int)(sizeof(languages) / sizeof(languages[0])); i ++)
|
||
if (!_cups_strcasecmp(languages[i].version, lang_version))
|
||
break;
|
||
|
||
if (i < (int)(sizeof(languages) / sizeof(languages[0])))
|
||
{
|
||
/*
|
||
* Found a known language...
|
||
*/
|
||
|
||
snprintf(lang_version, sizeof(lang_version), "%s%s",
|
||
languages[i].language, country);
|
||
}
|
||
else
|
||
{
|
||
/*
|
||
* Unknown language; use "xx"...
|
||
*/
|
||
|
||
strlcpy(lang_version, "xx", sizeof(lang_version));
|
||
}
|
||
|
||
/*
|
||
* Record the PPD file...
|
||
*/
|
||
|
||
new_ppd = !ppd;
|
||
|
||
if (new_ppd)
|
||
{
|
||
/*
|
||
* Add new PPD file...
|
||
*/
|
||
|
||
fprintf(stderr, "DEBUG2: [cups-driverd] Adding ppd \"%s\"...\n", name);
|
||
|
||
ppd = add_ppd(name, name, lang_version, manufacturer, make_model, device_id, (char *)cupsArrayFirst(products), (char *)cupsArrayFirst(psversions), fileinfo->st_mtime, (size_t)fileinfo->st_size, model_number, type, scheme);
|
||
|
||
if (!ppd)
|
||
return;
|
||
}
|
||
else
|
||
{
|
||
/*
|
||
* Update existing record...
|
||
*/
|
||
|
||
fprintf(stderr, "DEBUG2: [cups-driverd] Updating ppd \"%s\"...\n", name);
|
||
|
||
memset(ppd, 0, sizeof(ppd_info_t));
|
||
|
||
ppd->found = 1;
|
||
ppd->record.mtime = fileinfo->st_mtime;
|
||
ppd->record.size = fileinfo->st_size;
|
||
ppd->record.model_number = model_number;
|
||
ppd->record.type = type;
|
||
|
||
strlcpy(ppd->record.filename, name, sizeof(ppd->record.filename));
|
||
strlcpy(ppd->record.name, name, sizeof(ppd->record.name));
|
||
strlcpy(ppd->record.languages[0], lang_version,
|
||
sizeof(ppd->record.languages[0]));
|
||
strlcpy(ppd->record.products[0], (char *)cupsArrayFirst(products),
|
||
sizeof(ppd->record.products[0]));
|
||
strlcpy(ppd->record.psversions[0], (char *)cupsArrayFirst(psversions),
|
||
sizeof(ppd->record.psversions[0]));
|
||
strlcpy(ppd->record.make, manufacturer, sizeof(ppd->record.make));
|
||
strlcpy(ppd->record.make_and_model, make_model,
|
||
sizeof(ppd->record.make_and_model));
|
||
strlcpy(ppd->record.device_id, device_id, sizeof(ppd->record.device_id));
|
||
strlcpy(ppd->record.scheme, scheme, sizeof(ppd->record.scheme));
|
||
}
|
||
|
||
/*
|
||
* Add remaining products, versions, and languages...
|
||
*/
|
||
|
||
for (i = 1;
|
||
i < PPD_MAX_PROD && (ptr = (char *)cupsArrayNext(products)) != NULL;
|
||
i ++)
|
||
strlcpy(ppd->record.products[i], ptr,
|
||
sizeof(ppd->record.products[0]));
|
||
|
||
for (i = 1;
|
||
i < PPD_MAX_VERS && (ptr = (char *)cupsArrayNext(psversions)) != NULL;
|
||
i ++)
|
||
strlcpy(ppd->record.psversions[i], ptr,
|
||
sizeof(ppd->record.psversions[0]));
|
||
|
||
for (i = 1, ptr = (char *)cupsArrayFirst(cups_languages);
|
||
i < PPD_MAX_LANG && ptr;
|
||
i ++, ptr = (char *)cupsArrayNext(cups_languages))
|
||
strlcpy(ppd->record.languages[i], ptr,
|
||
sizeof(ppd->record.languages[0]));
|
||
|
||
/*
|
||
* Free products, versions, and languages...
|
||
*/
|
||
|
||
free_array(cups_languages);
|
||
free_array(products);
|
||
free_array(psversions);
|
||
|
||
ChangedPPD = 1;
|
||
}
|
||
|
||
|
||
/*
|
||
* 'load_ppds()' - Load PPD files recursively.
|
||
*/
|
||
|
||
static int /* O - 1 on success, 0 on failure */
|
||
load_ppds(const char *d, /* I - Actual directory */
|
||
const char *p, /* I - Virtual path in name */
|
||
int descend) /* I - Descend into directories? */
|
||
{
|
||
struct stat dinfo, /* Directory information */
|
||
*dinfoptr; /* Pointer to match */
|
||
cups_file_t *fp; /* Pointer to file */
|
||
cups_dir_t *dir; /* Directory pointer */
|
||
cups_dentry_t *dent; /* Directory entry */
|
||
char filename[1024], /* Name of PPD or directory */
|
||
line[256], /* Line from file */
|
||
*ptr, /* Pointer into name */
|
||
name[256]; /* Name of PPD file */
|
||
ppd_info_t *ppd, /* New PPD file */
|
||
key; /* Search key */
|
||
|
||
|
||
/*
|
||
* See if we've loaded this directory before...
|
||
*/
|
||
|
||
if (stat(d, &dinfo))
|
||
{
|
||
if (errno != ENOENT)
|
||
fprintf(stderr, "ERROR: [cups-driverd] Unable to stat \"%s\": %s\n", d,
|
||
strerror(errno));
|
||
|
||
return (0);
|
||
}
|
||
else if (cupsArrayFind(Inodes, &dinfo))
|
||
{
|
||
fprintf(stderr, "ERROR: [cups-driverd] Skipping \"%s\": loop detected!\n",
|
||
d);
|
||
return (1);
|
||
}
|
||
|
||
/*
|
||
* Nope, add it to the Inodes array and continue...
|
||
*/
|
||
|
||
dinfoptr = (struct stat *)malloc(sizeof(struct stat));
|
||
memcpy(dinfoptr, &dinfo, sizeof(struct stat));
|
||
cupsArrayAdd(Inodes, dinfoptr);
|
||
|
||
/*
|
||
* Check permissions...
|
||
*/
|
||
|
||
if (_cupsFileCheck(d, _CUPS_FILE_CHECK_DIRECTORY, !geteuid(),
|
||
_cupsFileCheckFilter, NULL))
|
||
return (0);
|
||
|
||
if ((dir = cupsDirOpen(d)) == NULL)
|
||
{
|
||
if (errno != ENOENT)
|
||
fprintf(stderr,
|
||
"ERROR: [cups-driverd] Unable to open PPD directory \"%s\": %s\n",
|
||
d, strerror(errno));
|
||
|
||
return (0);
|
||
}
|
||
|
||
fprintf(stderr, "DEBUG: [cups-driverd] Loading \"%s\"...\n", d);
|
||
|
||
while ((dent = cupsDirRead(dir)) != NULL)
|
||
{
|
||
/*
|
||
* Skip files/directories starting with "."...
|
||
*/
|
||
|
||
if (dent->filename[0] == '.')
|
||
continue;
|
||
|
||
/*
|
||
* See if this is a file...
|
||
*/
|
||
|
||
snprintf(filename, sizeof(filename), "%s/%s", d, dent->filename);
|
||
|
||
if (p[0])
|
||
snprintf(name, sizeof(name), "%s/%s", p, dent->filename);
|
||
else
|
||
strlcpy(name, dent->filename, sizeof(name));
|
||
|
||
if (S_ISDIR(dent->fileinfo.st_mode))
|
||
{
|
||
/*
|
||
* Do subdirectory...
|
||
*/
|
||
|
||
if (descend)
|
||
{
|
||
if (!load_ppds(filename, name, 1))
|
||
{
|
||
cupsDirClose(dir);
|
||
return (1);
|
||
}
|
||
}
|
||
else if ((ptr = filename + strlen(filename) - 14) > filename &&
|
||
!strcmp(ptr, ".printerDriver"))
|
||
{
|
||
/*
|
||
* Load PPDs in a printer driver bundle.
|
||
*/
|
||
|
||
if (_cupsFileCheck(filename, _CUPS_FILE_CHECK_DIRECTORY, !geteuid(),
|
||
_cupsFileCheckFilter, NULL))
|
||
continue;
|
||
|
||
strlcat(filename, "/Contents/Resources/PPDs", sizeof(filename));
|
||
strlcat(name, "/Contents/Resources/PPDs", sizeof(name));
|
||
|
||
load_ppds(filename, name, 0);
|
||
}
|
||
|
||
continue;
|
||
}
|
||
else if (strstr(filename, ".plist"))
|
||
{
|
||
/*
|
||
* Skip plist files in the PPDs directory...
|
||
*/
|
||
|
||
continue;
|
||
}
|
||
else if (_cupsFileCheck(filename, _CUPS_FILE_CHECK_FILE_ONLY, !geteuid(),
|
||
_cupsFileCheckFilter, NULL))
|
||
continue;
|
||
|
||
/*
|
||
* See if this file has been scanned before...
|
||
*/
|
||
|
||
strlcpy(key.record.filename, name, sizeof(key.record.filename));
|
||
strlcpy(key.record.name, name, sizeof(key.record.name));
|
||
|
||
ppd = (ppd_info_t *)cupsArrayFind(PPDsByName, &key);
|
||
|
||
if (ppd &&
|
||
ppd->record.size == dent->fileinfo.st_size &&
|
||
ppd->record.mtime == dent->fileinfo.st_mtime)
|
||
{
|
||
/*
|
||
* Rewind to the first entry for this file...
|
||
*/
|
||
|
||
while ((ppd = (ppd_info_t *)cupsArrayPrev(PPDsByName)) != NULL &&
|
||
!strcmp(ppd->record.filename, name));
|
||
|
||
/*
|
||
* Then mark all of the matches for this file as found...
|
||
*/
|
||
|
||
while ((ppd = (ppd_info_t *)cupsArrayNext(PPDsByName)) != NULL &&
|
||
!strcmp(ppd->record.filename, name))
|
||
ppd->found = 1;
|
||
|
||
continue;
|
||
}
|
||
|
||
/*
|
||
* No, file is new/changed, so re-scan it...
|
||
*/
|
||
|
||
if ((fp = cupsFileOpen(filename, "r")) == NULL)
|
||
continue;
|
||
|
||
/*
|
||
* Now see if this is a PPD file...
|
||
*/
|
||
|
||
line[0] = '\0';
|
||
cupsFileGets(fp, line, sizeof(line));
|
||
|
||
if (!strncmp(line, "*PPD-Adobe:", 11))
|
||
{
|
||
/*
|
||
* Yes, load it...
|
||
*/
|
||
|
||
load_ppd(filename, name, "file", &dent->fileinfo, ppd, fp, 0);
|
||
}
|
||
else
|
||
{
|
||
/*
|
||
* Nope, treat it as a driver information file or archive...
|
||
*/
|
||
|
||
cupsFileRewind(fp);
|
||
|
||
if ((ptr = strstr(filename, ".tar")) != NULL &&
|
||
(!strcmp(ptr, ".tar") || !strcmp(ptr, ".tar.gz")))
|
||
load_tar(filename, name, fp, dent->fileinfo.st_mtime,
|
||
dent->fileinfo.st_size);
|
||
else
|
||
load_drv(filename, name, fp, dent->fileinfo.st_mtime,
|
||
dent->fileinfo.st_size);
|
||
}
|
||
|
||
/*
|
||
* Close the file...
|
||
*/
|
||
|
||
cupsFileClose(fp);
|
||
}
|
||
|
||
cupsDirClose(dir);
|
||
|
||
return (1);
|
||
}
|
||
|
||
|
||
/*
|
||
* 'load_ppds_dat()' - Load the ppds.dat file.
|
||
*/
|
||
|
||
static void
|
||
load_ppds_dat(char *filename, /* I - Filename buffer */
|
||
size_t filesize, /* I - Size of filename buffer */
|
||
int verbose) /* I - Be verbose? */
|
||
{
|
||
ppd_info_t *ppd; /* Current PPD file */
|
||
cups_file_t *fp; /* ppds.dat file */
|
||
struct stat fileinfo; /* ppds.dat information */
|
||
const char *cups_cachedir; /* CUPS_CACHEDIR environment variable */
|
||
|
||
|
||
PPDsByName = cupsArrayNew((cups_array_func_t)compare_names, NULL);
|
||
PPDsByMakeModel = cupsArrayNew((cups_array_func_t)compare_ppds, NULL);
|
||
ChangedPPD = 0;
|
||
|
||
if (!filename[0])
|
||
{
|
||
if ((cups_cachedir = getenv("CUPS_CACHEDIR")) == NULL)
|
||
cups_cachedir = CUPS_CACHEDIR;
|
||
|
||
snprintf(filename, filesize, "%s/ppds.dat", cups_cachedir);
|
||
}
|
||
|
||
if ((fp = cupsFileOpen(filename, "r")) != NULL)
|
||
{
|
||
/*
|
||
* See if we have the right sync word...
|
||
*/
|
||
|
||
unsigned ppdsync; /* Sync word */
|
||
int num_ppds; /* Number of PPDs */
|
||
|
||
if ((size_t)cupsFileRead(fp, (char *)&ppdsync, sizeof(ppdsync)) == sizeof(ppdsync) &&
|
||
ppdsync == PPD_SYNC &&
|
||
!stat(filename, &fileinfo) &&
|
||
(((size_t)fileinfo.st_size - sizeof(ppdsync)) % sizeof(ppd_rec_t)) == 0 &&
|
||
(num_ppds = ((size_t)fileinfo.st_size - sizeof(ppdsync)) / sizeof(ppd_rec_t)) > 0)
|
||
{
|
||
/*
|
||
* We have a ppds.dat file, so read it!
|
||
*/
|
||
|
||
for (; num_ppds > 0; num_ppds --)
|
||
{
|
||
if ((ppd = (ppd_info_t *)calloc(1, sizeof(ppd_info_t))) == NULL)
|
||
{
|
||
if (verbose)
|
||
fputs("ERROR: [cups-driverd] Unable to allocate memory for PPD!\n",
|
||
stderr);
|
||
exit(1);
|
||
}
|
||
|
||
if (cupsFileRead(fp, (char *)&(ppd->record), sizeof(ppd_rec_t)) > 0)
|
||
{
|
||
cupsArrayAdd(PPDsByName, ppd);
|
||
cupsArrayAdd(PPDsByMakeModel, ppd);
|
||
}
|
||
else
|
||
{
|
||
free(ppd);
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (verbose)
|
||
fprintf(stderr, "INFO: [cups-driverd] Read \"%s\", %d PPDs...\n",
|
||
filename, cupsArrayCount(PPDsByName));
|
||
}
|
||
|
||
cupsFileClose(fp);
|
||
}
|
||
}
|
||
|
||
|
||
/*
|
||
* 'load_tar()' - Load archived PPD files.
|
||
*/
|
||
|
||
static int /* O - 1 on success, 0 on failure */
|
||
load_tar(const char *filename, /* I - Actual filename */
|
||
const char *name, /* I - Name to the rest of the world */
|
||
cups_file_t *fp, /* I - File to read from */
|
||
time_t mtime, /* I - Mod time of driver info file */
|
||
off_t size) /* I - Size of driver info file */
|
||
{
|
||
char curname[256], /* Current archive file name */
|
||
uri[1024]; /* Virtual file URI */
|
||
const char *curext; /* Extension on file */
|
||
struct stat curinfo; /* Current archive file information */
|
||
off_t next; /* Position for next header */
|
||
|
||
|
||
/*
|
||
* Add a dummy entry for the file...
|
||
*/
|
||
|
||
(void)filename;
|
||
|
||
add_ppd(name, name, "", "", "", "", "", "", mtime, (size_t)size, 0, PPD_TYPE_ARCHIVE, "file");
|
||
ChangedPPD = 1;
|
||
|
||
/*
|
||
* Scan for PPDs in the archive...
|
||
*/
|
||
|
||
while (read_tar(fp, curname, sizeof(curname), &curinfo))
|
||
{
|
||
next = cupsFileTell(fp) + ((curinfo.st_size + TAR_BLOCK - 1) &
|
||
~(TAR_BLOCK - 1));
|
||
|
||
if ((curext = strrchr(curname, '.')) != NULL &&
|
||
!_cups_strcasecmp(curext, ".ppd"))
|
||
{
|
||
httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "file", "", "",
|
||
0, "/%s/%s", name, curname);
|
||
load_ppd(name, uri, "file", &curinfo, NULL, fp, next);
|
||
}
|
||
|
||
if (cupsFileTell(fp) != next)
|
||
cupsFileSeek(fp, next);
|
||
}
|
||
|
||
return (1);
|
||
}
|
||
|
||
|
||
/*
|
||
* 'read_tar()' - Read a file header from an archive.
|
||
*
|
||
* This function skips all directories and special files.
|
||
*/
|
||
|
||
static int /* O - 1 if found, 0 on EOF */
|
||
read_tar(cups_file_t *fp, /* I - Archive to read */
|
||
char *name, /* I - Filename buffer */
|
||
size_t namesize, /* I - Size of filename buffer */
|
||
struct stat *info) /* O - File information */
|
||
{
|
||
tar_rec_t record; /* Record from file */
|
||
|
||
|
||
while ((size_t)cupsFileRead(fp, (char *)&record, sizeof(record)) == sizeof(record))
|
||
{
|
||
/*
|
||
* Check for a valid tar header...
|
||
*/
|
||
|
||
if (memcmp(record.header.magic, TAR_MAGIC, 6) ||
|
||
memcmp(record.header.version, TAR_VERSION, 2))
|
||
{
|
||
if (record.header.magic[0] ||
|
||
memcmp(record.header.magic, record.header.magic + 1, 5))
|
||
fputs("ERROR: [cups-driverd] Bad tar magic/version.\n", stderr);
|
||
break;
|
||
}
|
||
|
||
/*
|
||
* Ignore non-files...
|
||
*/
|
||
|
||
if (record.header.linkflag != TAR_OLDNORMAL &&
|
||
record.header.linkflag != TAR_NORMAL)
|
||
continue;
|
||
|
||
/*
|
||
* Grab size and name from tar header and return...
|
||
*/
|
||
|
||
if (record.header.prefix[0])
|
||
snprintf(name, namesize, "%s/%s", record.header.prefix,
|
||
record.header.pathname);
|
||
else
|
||
strlcpy(name, record.header.pathname, namesize);
|
||
|
||
info->st_mtime = strtol(record.header.mtime, NULL, 8);
|
||
info->st_size = strtoll(record.header.size, NULL, 8);
|
||
|
||
return (1);
|
||
}
|
||
|
||
return (0);
|
||
}
|
||
|
||
|
||
/*
|
||
* 'regex_device_id()' - Compile a regular expression based on the 1284 device
|
||
* ID.
|
||
*/
|
||
|
||
static regex_t * /* O - Regular expression */
|
||
regex_device_id(const char *device_id) /* I - IEEE-1284 device ID */
|
||
{
|
||
char res[2048], /* Regular expression string */
|
||
*ptr; /* Pointer into string */
|
||
regex_t *re; /* Regular expression */
|
||
int cmd; /* Command set string? */
|
||
|
||
|
||
fprintf(stderr, "DEBUG: [cups-driverd] regex_device_id(\"%s\")\n", device_id);
|
||
|
||
/*
|
||
* Scan the device ID string and insert class, command set, manufacturer, and
|
||
* model attributes to match. We assume that the device ID in the PPD and the
|
||
* device ID reported by the device itself use the same attribute names and
|
||
* order of attributes.
|
||
*/
|
||
|
||
ptr = res;
|
||
|
||
while (*device_id && ptr < (res + sizeof(res) - 6))
|
||
{
|
||
cmd = !_cups_strncasecmp(device_id, "COMMAND SET:", 12) ||
|
||
!_cups_strncasecmp(device_id, "CMD:", 4);
|
||
|
||
if (cmd || !_cups_strncasecmp(device_id, "MANUFACTURER:", 13) ||
|
||
!_cups_strncasecmp(device_id, "MFG:", 4) ||
|
||
!_cups_strncasecmp(device_id, "MFR:", 4) ||
|
||
!_cups_strncasecmp(device_id, "MODEL:", 6) ||
|
||
!_cups_strncasecmp(device_id, "MDL:", 4))
|
||
{
|
||
if (ptr > res)
|
||
{
|
||
*ptr++ = '.';
|
||
*ptr++ = '*';
|
||
}
|
||
|
||
*ptr++ = '(';
|
||
|
||
while (*device_id && *device_id != ';' && ptr < (res + sizeof(res) - 8))
|
||
{
|
||
if (strchr("[]{}().*\\|", *device_id))
|
||
*ptr++ = '\\';
|
||
if (*device_id == ':')
|
||
{
|
||
/*
|
||
* KEY:.*value
|
||
*/
|
||
|
||
*ptr++ = *device_id++;
|
||
*ptr++ = '.';
|
||
*ptr++ = '*';
|
||
}
|
||
else
|
||
*ptr++ = *device_id++;
|
||
}
|
||
|
||
if (*device_id == ';' || !*device_id)
|
||
{
|
||
/*
|
||
* KEY:.*value.*;
|
||
*/
|
||
|
||
*ptr++ = '.';
|
||
*ptr++ = '*';
|
||
*ptr++ = ';';
|
||
}
|
||
*ptr++ = ')';
|
||
if (cmd)
|
||
*ptr++ = '?';
|
||
}
|
||
else if ((device_id = strchr(device_id, ';')) == NULL)
|
||
break;
|
||
else
|
||
device_id ++;
|
||
}
|
||
|
||
*ptr = '\0';
|
||
|
||
fprintf(stderr, "DEBUG: [cups-driverd] regex_device_id: \"%s\"\n", res);
|
||
|
||
/*
|
||
* Compile the regular expression and return...
|
||
*/
|
||
|
||
if (res[0] && (re = (regex_t *)calloc(1, sizeof(regex_t))) != NULL)
|
||
{
|
||
if (!regcomp(re, res, REG_EXTENDED | REG_ICASE))
|
||
{
|
||
fputs("DEBUG: [cups-driverd] regex_device_id: OK\n", stderr);
|
||
return (re);
|
||
}
|
||
|
||
free(re);
|
||
}
|
||
|
||
return (NULL);
|
||
}
|
||
|
||
|
||
/*
|
||
* 'regex_string()' - Construct a regular expression to compare a simple string.
|
||
*/
|
||
|
||
static regex_t * /* O - Regular expression */
|
||
regex_string(const char *s) /* I - String to compare */
|
||
{
|
||
char res[2048], /* Regular expression string */
|
||
*ptr; /* Pointer into string */
|
||
regex_t *re; /* Regular expression */
|
||
|
||
|
||
fprintf(stderr, "DEBUG: [cups-driverd] regex_string(\"%s\")\n", s);
|
||
|
||
/*
|
||
* Convert the string to a regular expression, escaping special characters
|
||
* as needed.
|
||
*/
|
||
|
||
ptr = res;
|
||
|
||
while (*s && ptr < (res + sizeof(res) - 2))
|
||
{
|
||
if (strchr("[]{}().*\\", *s))
|
||
*ptr++ = '\\';
|
||
|
||
*ptr++ = *s++;
|
||
}
|
||
|
||
*ptr = '\0';
|
||
|
||
fprintf(stderr, "DEBUG: [cups-driverd] regex_string: \"%s\"\n", res);
|
||
|
||
/*
|
||
* Create a case-insensitive regular expression...
|
||
*/
|
||
|
||
if (res[0] && (re = (regex_t *)calloc(1, sizeof(regex_t))) != NULL)
|
||
{
|
||
if (!regcomp(re, res, REG_ICASE))
|
||
{
|
||
fputs("DEBUG: [cups-driverd] regex_string: OK\n", stderr);
|
||
return (re);
|
||
}
|
||
|
||
free(re);
|
||
}
|
||
|
||
return (NULL);
|
||
}
|