summaryrefslogtreecommitdiff
path: root/options.c
diff options
context:
space:
mode:
Diffstat (limited to 'options.c')
-rw-r--r--options.c2073
1 files changed, 2073 insertions, 0 deletions
diff --git a/options.c b/options.c
new file mode 100644
index 0000000..e39bf1e
--- /dev/null
+++ b/options.c
@@ -0,0 +1,2073 @@
+
+#include "foomaticrip.h"
+#include "options.h"
+#include "util.h"
+#include <stdlib.h>
+#include <ctype.h>
+#include <assert.h>
+#include <regex.h>
+#include <string.h>
+#include <math.h>
+
+
+/* Values from foomatic keywords in the ppd file */
+char printer_model [256];
+char printer_id [128];
+char driver [128];
+char cmd [1024];
+char cmd_pdf [1024];
+dstr_t *postpipe = NULL; /* command into which the output of this
+ filter should be piped */
+int ps_accounting = 1;
+char cupsfilter [256];
+
+/* JCL prefix to put before the JCL options
+ (Can be modified by a "*JCLBegin:" keyword in the ppd file): */
+char jclbegin[256] = "\033%-12345X@PJL\n";
+
+/* JCL command to switch the printer to the PostScript interpreter
+ (Can be modified by a "*JCLToPSInterpreter:" keyword in the PPD file): */
+char jcltointerpreter[256] = "";
+
+/* JCL command to close a print job
+ (Can be modified by a "*JCLEnd:" keyword in the PPD file): */
+char jclend[256] = "\033%-12345X@PJL RESET\n";
+
+/* Prefix for starting every JCL command
+ (Can be modified by "*FoomaticJCLPrefix:" keyword in the PPD file): */
+char jclprefix[256] = "@PJL ";
+int jclprefixset = 0;
+
+dstr_t *prologprepend;
+dstr_t *setupprepend;
+dstr_t *pagesetupprepend;
+
+
+
+option_t *optionlist = NULL;
+option_t *optionlist_sorted_by_order = NULL;
+
+int optionset_alloc, optionset_count;
+char **optionsets;
+
+
+
+
+const char * type_name(int type)
+{
+ switch (type) {
+ case TYPE_NONE:
+ return "none";
+ case TYPE_ENUM:
+ return "enum";
+ case TYPE_PICKMANY:
+ return "pickmany";
+ case TYPE_BOOL:
+ return "bool";
+ case TYPE_INT:
+ return "int";
+ case TYPE_FLOAT:
+ return "float";
+ case TYPE_STRING:
+ return "string";
+ };
+ _log("type '%d' does not exist\n", type);
+ return NULL;
+}
+
+int type_from_string(const char *typestr)
+{
+ int type = TYPE_NONE;
+
+ /* Official PPD options */
+ if (!strcmp(typestr, "PickOne"))
+ type = TYPE_ENUM;
+ else if (!strcmp(typestr, "PickMany"))
+ type = TYPE_PICKMANY;
+ else if (!strcmp(typestr, "Boolean"))
+ type = TYPE_BOOL;
+
+ /* FoomaticRIPOption */
+ else if (strcasecmp(typestr, "enum") == 0)
+ type = TYPE_ENUM;
+ else if (strcasecmp(typestr, "pickmany") == 0)
+ type = TYPE_PICKMANY;
+ else if (strcasecmp(typestr, "bool") == 0)
+ type = TYPE_BOOL;
+ else if (strcasecmp(typestr, "int") == 0)
+ type = TYPE_INT;
+ else if (strcasecmp(typestr, "float") == 0)
+ type = TYPE_FLOAT;
+ else if (strcasecmp(typestr, "string") == 0)
+ type = TYPE_STRING;
+ else if (strcasecmp(typestr, "password") == 0)
+ type = TYPE_PASSWORD;
+
+ return type;
+}
+
+char style_from_string(const char *style)
+{
+ char r = '\0';
+ if (strcmp(style, "PS") == 0)
+ r = 'G';
+ else if (strcmp(style, "CmdLine") == 0)
+ r = 'C';
+ else if (strcmp(style, "JCL") == 0)
+ r = 'J';
+ else if (strcmp(style, "Composite") == 0)
+ r = 'X';
+ return r;
+}
+
+int section_from_string(const char *value)
+{
+ if (!strcasecmp(value, "AnySetup"))
+ return SECTION_ANYSETUP;
+ else if (!strcasecmp(value, "PageSetup"))
+ return SECTION_PAGESETUP;
+ else if (!strcasecmp(value, "Prolog"))
+ return SECTION_PROLOG;
+ else if (!strcasecmp(value, "DocumentSetup"))
+ return SECTION_DOCUMENTSETUP;
+ else if (!strcasecmp(value, "JCLSetup"))
+ return SECTION_JCLSETUP;
+
+ _log("Unknown section: \"%s\"\n", value);
+ return 0;
+}
+
+void options_init()
+{
+ optionset_alloc = 8;
+ optionset_count = 0;
+ optionsets = calloc(optionset_alloc, sizeof(char *));
+
+ prologprepend = create_dstr();
+ setupprepend = create_dstr();
+ pagesetupprepend = create_dstr();
+}
+
+static void free_param(param_t *param)
+{
+ if (param->allowedchars) {
+ regfree(param->allowedchars);
+ free(param->allowedchars);
+ }
+
+ if (param->allowedregexp) {
+ regfree(param->allowedregexp);
+ free(param->allowedregexp);
+ }
+
+ free(param);
+}
+
+/*
+ * Values
+ */
+
+static void free_value(value_t *val)
+{
+ if (val->value)
+ free(val->value);
+ free(val);
+}
+
+
+/*
+ * Options
+ */
+static void free_option(option_t *opt)
+{
+ choice_t *choice;
+ param_t *param;
+ value_t *value;
+
+ free(opt->custom_command);
+ free(opt->proto);
+
+ while (opt->valuelist) {
+ value = opt->valuelist;
+ opt->valuelist = opt->valuelist->next;
+ free_value(value);
+ }
+ while (opt->choicelist) {
+ choice = opt->choicelist;
+ opt->choicelist = opt->choicelist->next;
+ free(choice);
+ }
+ while (opt->paramlist) {
+ param = opt->paramlist;
+ opt->paramlist = opt->paramlist->next;
+ free_param(param);
+ }
+ if (opt->foomatic_param)
+ free_param(opt->foomatic_param);
+
+ free(opt);
+}
+
+void options_free()
+{
+ option_t *opt;
+ int i;
+
+ for (i = 0; i < optionset_count; i++)
+ free(optionsets[i]);
+ free(optionsets);
+ optionsets = NULL;
+ optionset_alloc = 0;
+ optionset_count = 0;
+
+ while (optionlist) {
+ opt = optionlist;
+ optionlist = optionlist->next;
+ free_option(opt);
+ }
+
+ if (postpipe)
+ free_dstr(postpipe);
+
+ free_dstr(prologprepend);
+ free_dstr(setupprepend);
+ free_dstr(pagesetupprepend);
+}
+
+size_t option_count()
+{
+ option_t *opt;
+ size_t cnt = 0;
+
+ for (opt = optionlist; opt; opt = opt->next)
+ cnt++;
+ return cnt;
+}
+
+option_t * find_option(const char *name)
+{
+ option_t *opt;
+
+ /* PageRegion and PageSize are the same options, just store one of them */
+ if (!strcasecmp(name, "PageRegion"))
+ return find_option("PageSize");
+
+ for (opt = optionlist; opt; opt = opt->next) {
+ if (!strcasecmp(opt->name, name))
+ return opt;
+ }
+ return NULL;
+}
+
+option_t * assure_option(const char *name)
+{
+ option_t *opt, *last;
+
+ if ((opt = find_option(name)))
+ return opt;
+
+ opt = calloc(1, sizeof(option_t));
+
+ /* PageRegion and PageSize are the same options, just store one of them */
+ if (!strcmp(name, "PageRegion"))
+ strlcpy(opt->name, "PageSize", 128);
+ else
+ strlcpy(opt->name, name, 128);
+
+ /* set varname */
+ strcpy(opt->varname, opt->name);
+ strrepl(opt->varname, "-/.", '_');
+
+ /* Default execution style is 'G' (PostScript) since all arguments for
+ which we don't find "*Foomatic..." keywords are usual PostScript options */
+ opt->style = 'G';
+
+ opt->type = TYPE_NONE;
+
+ /* append opt to optionlist */
+ if (optionlist) {
+ for (last = optionlist; last->next; last = last->next);
+ last->next = opt;
+ }
+ else
+ optionlist = opt;
+
+ /* prepend opt to optionlist_sorted_by_order
+ (0 is always at the beginning) */
+ if (optionlist_sorted_by_order) {
+ opt->next_by_order = optionlist_sorted_by_order;
+ optionlist_sorted_by_order = opt;
+ }
+ else {
+ optionlist_sorted_by_order = opt;
+ }
+
+ _log("Added option %s\n", opt->name);
+ return opt;
+}
+
+/* This functions checks if "opt" is named "name", or if it has any
+ alternative names "name" (e.g. PageSize / PageRegion) */
+int option_has_name(option_t *opt, const char *name)
+{
+ if (!strcmp(opt->name, name))
+ return 1;
+
+ if (!strcmp(opt->name, "PageSize") && !strcmp(name, "PageRegion"))
+ return 1;
+
+ return 0;
+}
+
+int option_is_composite(option_t *opt)
+{
+ return opt ? (opt->style == 'X') : 0;
+}
+
+int option_is_ps_command(option_t *opt)
+{
+ return opt->style == 'G';
+}
+
+int option_is_jcl_arg(option_t *opt)
+{
+ return opt->style == 'J';
+}
+
+int option_is_commandline_arg(option_t *opt)
+{
+ return opt->style == 'C';
+}
+
+int option_get_section(option_t *opt)
+{
+ return opt->section;
+}
+
+static value_t * option_find_value(option_t *opt, int optionset)
+{
+ value_t *val;
+
+ if (!opt)
+ return NULL;
+
+ for (val = opt->valuelist; val; val = val->next) {
+ if (val->optionset == optionset)
+ return val;
+ }
+ return NULL;
+}
+
+static value_t * option_assure_value(option_t *opt, int optionset)
+{
+ value_t *val, *last;
+ val = option_find_value(opt, optionset);
+ if (!val) {
+ val = calloc(1, sizeof(value_t));
+ val->optionset = optionset;
+
+ /* append to opt->valuelist */
+ if (opt->valuelist) {
+ for (last = opt->valuelist; last->next; last = last->next);
+ last->next = val;
+ }
+ else
+ opt->valuelist = val;
+ }
+ return val;
+}
+
+static param_t * option_find_param_index(option_t *opt, const char *name, int *idx)
+{
+ param_t *param;
+ int i;
+ for (param = opt->paramlist, i = 0; param; param = param->next, i += 1) {
+ if (!strcasecmp(param->name, name)) {
+ if (idx)
+ *idx = i;
+ return param;
+ }
+ }
+ if (idx)
+ *idx = -1;
+ return 0;
+}
+
+static choice_t * option_find_choice(option_t *opt, const char *name)
+{
+ choice_t *choice;
+ assert(opt && name);
+ for (choice = opt->choicelist; choice; choice = choice->next) {
+ if (!strcasecmp(choice->value, name))
+ return choice;
+ }
+ return NULL;
+}
+
+void free_paramvalues(option_t *opt, char **paramvalues)
+{
+ int i;
+ if (!paramvalues)
+ return;
+ for (i = 0; i < opt->param_count; i++)
+ free(paramvalues[i]);
+ free(paramvalues);
+}
+
+char * get_valid_param_string(option_t *opt, param_t *param, const char *str)
+{
+ char *result;
+ int i, imin, imax;
+ float f, fmin, fmax;
+ size_t len;
+
+ switch (param->type) {
+ case TYPE_INT:
+ i = atoi(str);
+ imin = !isempty(param->min) ? atoi(param->min) : -999999;
+ imax = !isempty(param->max) ? atoi(param->max) : 1000000;
+ if (i < imin) {
+ _log("Value \"%s\" for option \"%s.%s\" is smaller than the minimum value \"%d\"\n",
+ str, opt->name, param->name, imin);
+ return NULL;
+ }
+ else if (i > imax) {
+ _log("Value \"%s\" for option \"%s.%s\" is larger than the maximum value \"%d\"\n",
+ str, opt->name, param->name, imax);
+ return NULL;
+ }
+ result = malloc(32);
+ snprintf(result, 32, "%d", i);
+ return result;
+
+ case TYPE_FLOAT:
+ case TYPE_CURVE:
+ case TYPE_INVCURVE:
+ case TYPE_POINTS:
+ f = atof(str);
+ fmin = !isempty(param->min) ? atof(param->min) : -999999.0;
+ fmax = !isempty(param->max) ? atof(param->max) : 1000000.0;
+ if (f < fmin) {
+ _log("Value \"%s\" for option \"%s.%s\" is smaller than the minimum value \"%d\"\n",
+ str, opt->name, param->name, fmin);
+ return NULL;
+ }
+ else if (f > fmax) {
+ _log("Value \"%s\" for option \"%s.%s\" is larger than the maximum value \"%d\"\n",
+ str, opt->name, param->name, fmax);
+ return NULL;
+ }
+ result = malloc(32);
+ snprintf(result, 32, "%f", f);
+ return result;
+
+ case TYPE_STRING:
+ case TYPE_PASSWORD:
+ case TYPE_PASSCODE:
+ if (param->allowedchars &&
+ regexec(param->allowedchars, str, 0, NULL, 0) != 0) {
+ _log("Custom string \"%s\" for \"%s.%s\" contains illegal characters.\n",
+ str, opt->name, param->name);
+ return NULL;
+ }
+ if (param->allowedregexp &&
+ regexec(param->allowedregexp, str, 0, NULL, 0) != 0) {
+ _log("Custom string \"%s\" for \"%s.%s\" does not match the allowed regexp.\n",
+ str, opt->name, param->name);
+ return NULL;
+ }
+ len = strlen(str);
+ if (!isempty(param->min) && len < atoi(param->min)) {
+ _log("Custom value \"%s\" is too short for \"%s.%s\".\n",
+ str, opt->name, param->name);
+ return NULL;
+ }
+ if (!isempty(param->max) && len > atoi(param->max)) {
+ _log("Custom value \"%s\" is too long for \"%s.%s\".\n",
+ str, opt->name, param->name);
+ return NULL;
+ }
+ return strdup(str);
+ }
+ return NULL;
+}
+
+char * get_valid_param_string_int(option_t *opt, param_t *param, int value)
+{
+ char str[20];
+ snprintf(str, 20, "%d", value);
+ return get_valid_param_string(opt, param, str);
+}
+
+char * get_valid_param_string_float(option_t *opt, param_t *param, float value)
+{
+ char str[20];
+ snprintf(str, 20, "%f", value);
+ return get_valid_param_string(opt, param, str);
+}
+
+float convert_to_points(float f, const char *unit)
+{
+ if (!strcasecmp(unit, "pt"))
+ return roundf(f);
+ if (!strcasecmp(unit, "in"))
+ return roundf(f * 72.0);
+ if (!strcasecmp(unit, "cm"))
+ return roundf(f * 72.0 / 2.54);
+ if (!strcasecmp(unit, "mm"))
+ return roundf(f * 72.0 / 25.4);
+
+ _log("Unknown unit: \"%s\"\n", unit);
+ return roundf(f);
+}
+
+static char ** paramvalues_from_string(option_t *opt, const char *str)
+{
+ char ** paramvalues;
+ int n, i;
+ param_t *param;
+ char *copy, *cur, *p;
+ float width, height;
+ char unit[3];
+
+ if (!strcmp(opt->name, "PageSize"))
+ {
+ if (startswith(str, "Custom."))
+ str = &str[7];
+ /* 'unit' is optional, if it is not given, 'pt' is assumed */
+ n = sscanf(str, "%fx%f%2s", &width, &height, unit);
+ if (n > 1) {
+ if (n == 3) {
+ width = convert_to_points(width, unit);
+ height = convert_to_points(height, unit);
+ }
+ paramvalues = calloc(opt->param_count, sizeof(char*));
+ for (param = opt->paramlist, i = 0; param; param = param->next, i++) {
+ if (!strcasecmp(param->name, "width"))
+ paramvalues[i] = get_valid_param_string_int(opt, param, (int)width);
+ else if (!strcasecmp(param->name, "height"))
+ paramvalues[i] = get_valid_param_string_int(opt, param, (int)height);
+ else
+ paramvalues[i] = get_valid_param_string(opt, param, "0");
+ if (!paramvalues[i]) {
+ free_paramvalues(opt, paramvalues);
+ return NULL;
+ }
+ }
+ return paramvalues;
+ }
+ }
+
+ if (opt->param_count == 1) {
+ paramvalues = malloc(sizeof(char*));
+ paramvalues[0] = get_valid_param_string(opt, opt->paramlist,
+ startswith(str, "Custom.") ? &str[7] : str);
+ if (!paramvalues[0]) {
+ free(paramvalues);
+ return NULL;
+ }
+ }
+ else {
+ if (!(p = strchr(str, '{')))
+ return NULL;
+ paramvalues = calloc(opt->param_count, sizeof(char*));
+ copy = strdup(p +1);
+ for (cur = strtok(copy, " \t}"); cur; cur = strtok(NULL, " \t}")) {
+ p = strchr(cur, '=');
+ if (!p)
+ continue;
+ *p++ = '\0';
+ if ((param = option_find_param_index(opt, cur, &i)))
+ paramvalues[i] = get_valid_param_string(opt, param, p);
+ else
+ _log("Could not find param \"%s\" for option \"%s\"\n",
+ cur, opt->name);
+ }
+ free(copy);
+
+ /* check if all params have been set */
+ for (i = 0; i < opt->param_count; i++) {
+ if (!paramvalues[i]) {
+ free_paramvalues(opt, paramvalues);
+ return NULL;
+ }
+ }
+ }
+ return paramvalues;
+}
+
+char * paramvalues_to_string(option_t *opt, char **paramvalues)
+{
+ int i;
+ param_t *param;
+ dstr_t *res = create_dstr();
+ char *data;
+
+ if (opt->param_count < 1)
+ return NULL;
+
+ if (opt->param_count == 1) {
+ param = opt->paramlist;
+ dstrcpyf(res, "Custom.%s", paramvalues[0]);
+ }
+ else {
+ dstrcpyf(res, "{%s=%s", opt->paramlist->name, paramvalues[0]);
+ param = opt->paramlist->next;
+ i = 1;
+ while (param) {
+ dstrcatf(res, " %s=%s", param->name, paramvalues[i]);
+ i++;
+ param = param->next;
+ }
+ dstrcat(res, "}");
+ }
+ /* only free dstr struct, NOT the string data */
+ data = res->data;
+ free(res);
+ return data;
+}
+
+char * get_valid_value_string(option_t *opt, const char *value)
+{
+ char *res;
+ choice_t *choice;
+ char **paramvalues;
+
+ if (!value)
+ return NULL;
+
+ if (startswith(value, "From") && option_is_composite(find_option(&value[4])))
+ return strdup(value);
+
+ if (opt->type == TYPE_BOOL) {
+ if (is_true_string(value))
+ return strdup("1");
+ else if (is_false_string(value))
+ return strdup("0");
+ else {
+ _log("Could not interpret \"%s\" as boolean value for option \"%s\".\n", value, opt->name);
+ return NULL;
+ }
+ }
+
+ /* Check if "value" is a predefined choice (except for "Custom", which is
+ * not really a predefined choice, but an error if used without further
+ * parameters) */
+ if (strcmp(value, "Custom") != 0 && (choice = option_find_choice(opt, value)))
+ return strdup(choice->value);
+
+ if (opt->type == TYPE_ENUM) {
+ if (!strcasecmp(value, "none"))
+ return strdup("None");
+
+ /*
+ * CUPS assumes that options with the choices "Yes", "No", "On", "Off",
+ * "True", or "False" are boolean options and maps "-o Option=On" to
+ * "-o Option" and "-o Option=Off" to "-o noOption", which foomatic-rip
+ * maps to "0" and "1". So when "0" or "1" is unavailable in the
+ * option, we try "Yes", "No", "On", "Off", "True", and "False".
+ */
+ if (is_true_string(value)) {
+ for (choice = opt->choicelist; choice; choice = choice->next) {
+ if (is_true_string(choice->value))
+ return strdup(choice->value);
+ }
+ }
+ else if (is_false_string(value)) {
+ for (choice = opt->choicelist; choice; choice = choice->next) {
+ if (is_false_string(choice->value))
+ return strdup(choice->value);
+ }
+ }
+ }
+
+ /* Custom value */
+ if (opt->paramlist) {
+ paramvalues = paramvalues_from_string(opt, value);
+ if (paramvalues) {
+ res = paramvalues_to_string(opt, paramvalues);
+ free(paramvalues);
+ return (startswith(res, "Custom.") ? strdup(&res[7]) : strdup(res));
+ }
+ }
+ else if (opt->foomatic_param)
+ return get_valid_param_string(opt, opt->foomatic_param,
+ startswith(value, "Custom.") ? &value[7] : value);
+
+ /* Return the default value */
+ return NULL;
+}
+
+/* Returns the current value for 'opt' in 'optionset'. */
+const char * option_get_value(option_t *opt, int optionset)
+{
+ value_t *val = option_find_value(opt, optionset);
+ return val ? val->value : NULL;
+}
+
+/* Returns non-zero if the foomatic prototype should be used for that
+ * optionset, otherwise the custom_command will be used */
+int option_use_foomatic_prototype(option_t *opt)
+{
+ /* Only PostScript and JCL options can be CUPS custom options */
+ if (!option_is_ps_command(opt) && !option_is_jcl_arg(opt))
+ return 1;
+
+ /* if only one of them exists, take that one */
+ if (opt->custom_command && !opt->proto)
+ return 0;
+ if (!opt->custom_command && opt->proto)
+ return 1;
+ return 0;
+}
+
+void build_foomatic_custom_command(dstr_t *cmd, option_t *opt, const char *values)
+{
+ if (!opt->proto && !strcmp(opt->name, "PageSize"))
+ {
+ choice_t *choice = option_find_choice(opt, "Custom");
+ char ** paramvalues = paramvalues_from_string(opt, values);
+ char width[30], height[20];
+ int pos;
+
+ assert(choice);
+
+ /* Get rid of the trailing ".00000", it confuses ghostscript */
+ snprintf(width, 20, "%d", atoi(paramvalues[0]));
+ snprintf(height, 20, "%d", atoi(paramvalues[1]));
+
+ dstrcpy(cmd, choice->command);
+
+ if ((pos = dstrreplace(cmd, "%0", width, 0)) < 0)
+ pos = dstrreplace(cmd, "0", width, 0);
+
+ if ((pos = dstrreplace(cmd, "%1", height, pos) < 0))
+ dstrreplace(cmd, "0", height, pos);
+
+ free_paramvalues(opt, paramvalues);
+ }
+ else
+ {
+ dstrcpy(cmd, opt->proto);
+ /* use replace instead of printf-style because opt->proto could contain
+ other format strings */
+ dstrreplace(cmd, "%s", values, 0);
+ }
+}
+
+void build_cups_custom_ps_command(dstr_t *cmd, option_t *opt, const char *values)
+{
+ param_t *param;
+ int i;
+ char **paramvalues = paramvalues_from_string(opt, values);
+
+ dstrclear(cmd);
+ for (param = opt->paramlist, i = 0; param; param = param->next, i++)
+ dstrcatf(cmd, "%s ", paramvalues[i]);
+ dstrcat(cmd, opt->custom_command);
+ free_paramvalues(opt, paramvalues);
+}
+
+void build_cups_custom_jcl_command(dstr_t *cmd, option_t *opt, const char *values)
+{
+ param_t *param;
+ int i;
+ char orderstr[8];
+ char **paramvalues = paramvalues_from_string(opt, values);
+
+ dstrcpy(cmd, opt->custom_command);
+ for (param = opt->paramlist, i = 0; param; param = param->next, i++) {
+ snprintf(orderstr, 8, "\\%d", param->order);
+ dstrreplace(cmd, orderstr, paramvalues[i], 0);
+ }
+ free_paramvalues(opt, paramvalues);
+}
+
+int composite_get_command(dstr_t *cmd, option_t *opt, int optionset, int section)
+{
+ char *copy, *cur, *p;
+ option_t *dep;
+ const char * valstr;
+ dstr_t *depcmd;
+
+ dstrclear(cmd);
+ if (!option_is_composite(opt))
+ return 0;
+
+ if (!(valstr = option_get_value(opt, optionset)))
+ return 0;
+
+ depcmd = create_dstr();
+ copy = strdup(valstr);
+ /* Dependent options have been set to the right value in composite_set_values,
+ so just find out which options depend on this composite and get their commands
+ for "optionset" with option_get_command() */
+ for (cur = strtok(copy, " \t"); cur; cur = strtok(NULL, " \t")) {
+ dstrclear(depcmd);
+ if ((p = strchr(cur, '='))) {
+ *p++ = '\0';
+ if ((dep = find_option(cur)))
+ option_get_command(depcmd, dep, optionset, section);
+ }
+ else if (startswith(cur, "no") || startswith(cur, "No")) {
+ if ((dep = find_option(&cur[2])))
+ option_get_command(depcmd, dep, optionset, section);
+ }
+ else {
+ if ((dep = find_option(cur)))
+ option_get_command(depcmd, dep, optionset, section);
+ }
+ if (depcmd->len)
+ dstrcatf(cmd, "%s\n", depcmd->data);
+ }
+ free(copy);
+ free_dstr(depcmd);
+ return cmd->len != 0;
+}
+
+int option_is_in_section(option_t *opt, int section)
+{
+ if (opt->section == section)
+ return 1;
+ if (opt->section == SECTION_ANYSETUP && (section == SECTION_PAGESETUP || section == SECTION_DOCUMENTSETUP))
+ return 1;
+ return 0;
+}
+
+int option_is_custom_value(option_t *opt, const char *value)
+{
+ if (opt->type == TYPE_BOOL || opt->type == TYPE_ENUM)
+ return 0;
+
+ return !option_has_choice(opt, value);
+}
+
+int option_get_command(dstr_t *cmd, option_t *opt, int optionset, int section)
+{
+ const char *valstr;
+ choice_t *choice = NULL;
+
+ dstrclear(cmd);
+
+ if (option_is_composite(opt))
+ return composite_get_command(cmd, opt, optionset, section);
+
+ if (section >= 0 && !option_is_in_section(opt, section))
+ return 1; /* empty command for this section */
+
+ valstr = option_get_value(opt, optionset);
+ if (!valstr)
+ return 0;
+
+ /* If the value is set to a predefined choice */
+ choice = option_find_choice(opt, valstr);
+ if (choice) {
+ dstrcpy(cmd, choice->command);
+ return 1;
+ }
+
+ /* Consider "None" as the empty string for string and password options */
+ if ((opt->type == TYPE_STRING || opt->type == TYPE_PASSWORD) &&
+ !strcasecmp(valstr, "None"))
+ valstr = "";
+
+ /* Custom value */
+ if (option_use_foomatic_prototype(opt))
+ build_foomatic_custom_command(cmd, opt, valstr);
+ else {
+ dstrcpy(cmd, opt->custom_command);
+ if ((option_get_section(opt) == SECTION_JCLSETUP) ||
+ (opt->style == 'J'))
+ build_cups_custom_jcl_command(cmd, opt, valstr);
+ else
+ build_cups_custom_ps_command(cmd, opt, valstr);
+ }
+
+ return cmd->len != 0;
+}
+
+void composite_set_values(option_t *opt, int optionset, const char *values)
+{
+ char *copy, *cur, *p;
+ option_t *dep;
+ value_t *val;
+
+ copy = strdup(values);
+ for (cur = strtok(copy, " \t"); cur; cur = strtok(NULL, " \t")) {
+ if ((p = strchr(cur, '='))) {
+ *p++ = '\0';
+ if ((dep = find_option(cur))) {
+ val = option_assure_value(dep, optionset);
+ val->fromoption = opt;
+ val->value = get_valid_value_string(dep, p);
+ }
+ else
+ _log("Could not find option \"%s\" (set from composite \"%s\")", cur, opt->name);
+ }
+ else if (startswith(cur, "no") || startswith(cur, "No")) {
+ if ((dep = find_option(&cur[2]))) {
+ val = option_assure_value(dep, optionset);
+ val->fromoption = opt;
+ val->value = get_valid_value_string(dep, "0");
+ }
+ }
+ else {
+ if ((dep = find_option(cur))) {
+ val = option_assure_value(dep, optionset);
+ val->fromoption = opt;
+ val->value = get_valid_value_string(dep, "1");
+ }
+ }
+ }
+ free(copy);
+}
+
+int option_set_value(option_t *opt, int optionset, const char *value)
+{
+ value_t *val = option_assure_value(opt, optionset);
+ char *newvalue;
+ choice_t *choice;
+ option_t *fromopt;
+
+ newvalue = get_valid_value_string(opt, value);
+ if (!newvalue)
+ return 0;
+
+ free(val->value);
+ val->value = NULL;
+
+ if (startswith(newvalue, "From") && (fromopt = find_option(&newvalue[4])) &&
+ option_is_composite(fromopt)) {
+ /* TODO only set the changed option, not all of them */
+ choice = option_find_choice(fromopt,
+ option_get_value(fromopt, optionset));
+
+ composite_set_values(fromopt, optionset, choice->command);
+ }
+ else {
+ val->value = newvalue;
+ }
+
+ if (option_is_composite(opt)) {
+ /* set dependent values */
+ choice = option_find_choice(opt, value);
+ if (choice && !isempty(choice->command))
+ composite_set_values(opt, optionset, choice->command);
+ }
+ return 1;
+}
+
+int option_accepts_value(option_t *opt, const char *value)
+{
+ char *val = get_valid_value_string(opt, value);
+ if (!val)
+ return 0;
+ free(val);
+ return 1;
+}
+
+int option_has_choice(option_t *opt, const char *choice)
+{
+ return option_find_choice(opt, choice) != NULL;
+}
+
+const char * option_text(option_t *opt)
+{
+ if (isempty(opt->text))
+ return opt->text;
+ return opt->text;
+}
+
+int option_type(option_t *opt)
+{
+ return opt->type;
+}
+
+void option_set_order(option_t *opt, double order)
+{
+ option_t *prev;
+
+ /* remove opt from old position */
+ if (opt == optionlist_sorted_by_order)
+ optionlist_sorted_by_order = opt->next_by_order;
+ else {
+ for (prev = optionlist_sorted_by_order;
+ prev && prev->next_by_order != opt;
+ prev = prev->next_by_order);
+ prev->next_by_order = opt->next_by_order;
+ }
+
+ opt->order = order;
+
+ /* insert into new position */
+ if (!optionlist_sorted_by_order)
+ optionlist_sorted_by_order = opt;
+ else if (optionlist_sorted_by_order->order > opt->order) {
+ opt->next_by_order = optionlist_sorted_by_order;
+ optionlist_sorted_by_order = opt;
+ }
+ else {
+ for (prev = optionlist_sorted_by_order;
+ prev->next_by_order && prev->next_by_order->order < opt->order;
+ prev = prev->next_by_order);
+ opt->next_by_order = prev->next_by_order;
+ prev->next_by_order = opt;
+ }
+}
+
+/* Set option from *FoomaticRIPOption keyword */
+void option_set_from_string(option_t *opt, const char *str)
+{
+ char type[32], style[32];
+ double order;
+ int matches;
+
+ matches = sscanf(str, "%31s %31s %c %lf", type, style, &opt->spot, &order);
+ if (matches < 3) {
+ _log("Can't read the value of *FoomaticRIPOption for \"%s\"", opt->name);
+ return;
+ }
+ opt->type = type_from_string(type);
+ opt->style = style_from_string(style);
+
+ if (matches == 4)
+ option_set_order(opt, order);
+}
+
+static choice_t * option_assure_choice(option_t *opt, const char *name)
+{
+ choice_t *choice, *last = NULL;
+
+ for (choice = opt->choicelist; choice; choice = choice->next) {
+ if (!strcasecmp(choice->value, name))
+ return choice;
+ last = choice;
+ }
+ if (!choice) {
+ choice = calloc(1, sizeof(choice_t));
+ if (last)
+ last->next = choice;
+ else
+ opt->choicelist = choice;
+ strlcpy(choice->value, name, 128);
+ }
+ return choice;
+}
+
+static void unhtmlify(char *dest, size_t size, const char *src)
+{
+ jobparams_t *job = get_current_job();
+ char *pdest = dest;
+ const char *psrc = src;
+ const char *repl;
+ struct tm *t = localtime(&job->time);
+ char tmpstr[10];
+
+ while (*psrc && pdest - dest < size) {
+
+ if (*psrc == '&') {
+ psrc++;
+ repl = NULL;
+
+ /* Replace HTML/XML entities by the original characters */
+ if (!prefixcmp(psrc, "apos;"))
+ repl = "\'";
+ else if (!prefixcmp(psrc, "quot;"))
+ repl = "\"";
+ else if (!prefixcmp(psrc, "gt;"))
+ repl = ">";
+ else if (!prefixcmp(psrc, "lt;"))
+ repl = "<";
+ else if (!prefixcmp(psrc, "amp;"))
+ repl = "&";
+
+ /* Replace special entities by job->data */
+ else if (!prefixcmp(psrc, "job;"))
+ repl = job->id;
+ else if (!prefixcmp(psrc, "user;"))
+ repl = job->user;
+ else if (!prefixcmp(psrc, "host;"))
+ repl = job->host;
+ else if (!prefixcmp(psrc, "title;"))
+ repl = job->title;
+ else if (!prefixcmp(psrc, "copies;"))
+ repl = job->copies;
+ else if (!prefixcmp(psrc, "rbinumcopies;")) {
+ if (job->rbinumcopies > 0) {
+ snprintf(tmpstr, 10, "%d", job->rbinumcopies);
+ repl = tmpstr;
+ }
+ else
+ repl = job->copies;
+ }
+ else if (!prefixcmp(psrc, "options;"))
+ repl = job->optstr->data;
+ else if (!prefixcmp(psrc, "year;")) {
+ sprintf(tmpstr, "%04d", t->tm_year + 1900);
+ repl = tmpstr;
+ }
+ else if (!prefixcmp(psrc, "month;")) {
+ sprintf(tmpstr, "%02d", t->tm_mon + 1);
+ repl = tmpstr;
+ }
+ else if (!prefixcmp(psrc, "date;")) {
+ sprintf(tmpstr, "%02d", t->tm_mday);
+ repl = tmpstr;
+ }
+ else if (!prefixcmp(psrc, "hour;")) {
+ sprintf(tmpstr, "%02d", t->tm_hour);
+ repl = tmpstr;
+ }
+ else if (!prefixcmp(psrc, "min;")) {
+ sprintf(tmpstr, "%02d", t->tm_min);
+ repl = tmpstr;
+ }
+ else if (!prefixcmp(psrc, "sec;")) {
+ sprintf(tmpstr, "%02d", t->tm_sec);
+ repl = tmpstr;
+ }
+
+ if (repl) {
+ strncpy(pdest, repl, size - (pdest - dest));
+ pdest += strlen(repl);
+ psrc = strchr(psrc, ';') +1;
+ }
+ else {
+ *pdest = '&';
+ pdest++;
+ }
+ }
+ else {
+ *pdest = *psrc;
+ pdest++;
+ psrc++;
+ }
+ }
+ *pdest = '\0';
+}
+
+/*
+ * Checks whether 'code' contains active PostScript, i.e. not only comments
+ */
+static int contains_active_postscript(const char *code)
+{
+ char **line, **lines;
+ int contains_ps = 0;
+
+ if (!(lines = argv_split(code, "\n", NULL)))
+ return 0;
+
+ for (line = lines; *line && !contains_ps; line++)
+ contains_ps = !isempty(*line) &&
+ !startswith(skip_whitespace(*line), "%");
+
+ argv_free(lines);
+ return contains_ps;
+}
+
+void option_set_choice(option_t *opt, const char *name, const char *text,
+ const char *code)
+{
+ choice_t *choice;
+
+ if (opt->type == TYPE_BOOL) {
+ if (is_true_string(name))
+ choice = option_assure_choice(opt, "1");
+ else
+ choice = option_assure_choice(opt, "0");
+ }
+ else
+ choice = option_assure_choice(opt, name);
+
+ if (text)
+ strlcpy(choice->text, text, 128);
+
+ if (!code)
+ {
+ _log("Warning: No code for choice \"%s\" of option \"%s\"\n",
+ choice->text, opt->name);
+ return;
+ }
+
+ if (!startswith(code, "%% FoomaticRIPOptionSetting"))
+ unhtmlify(choice->command, 1024, code);
+}
+
+/*
+ * Parameters
+ */
+
+int param_set_allowed_chars(param_t *param, const char *value)
+{
+ char rxstr[128], tmp[128];
+
+ param->allowedchars = malloc(sizeof(regex_t));
+ unhtmlify(tmp, 128, value);
+ snprintf(rxstr, 128, "^[%s]*$", tmp);
+ if (regcomp(param->allowedchars, rxstr, 0) != 0) {
+ regfree(param->allowedchars);
+ param->allowedchars = NULL;
+ return 0;
+ }
+ return 1;
+}
+
+int param_set_allowed_regexp(param_t *param, const char *value)
+{
+ char tmp[128];
+
+ param->allowedregexp = malloc(sizeof(regex_t));
+ unhtmlify(tmp, 128, value);
+ if (regcomp(param->allowedregexp, tmp, 0) != 0) {
+ regfree(param->allowedregexp);
+ param->allowedregexp = NULL;
+ return 0;
+ }
+ return 1;
+}
+
+void option_set_custom_command(option_t *opt, const char *cmd)
+{
+ size_t len = strlen(cmd) + 50;
+ free(opt->custom_command);
+ opt->custom_command = malloc(len);
+ unhtmlify(opt->custom_command, len, cmd);
+}
+
+param_t * option_add_custom_param_from_string(option_t *opt,
+ const char *name, const char *text, const char *str)
+{
+ param_t *param = calloc(1, sizeof(param_t));
+ param_t *p;
+ char typestr[33];
+ int n;
+
+ strlcpy(param->name, name, 128);
+ strlcpy(param->text, text, 128);
+
+ n = sscanf(str, "%d%15s%19s%19s",
+ &param->order, typestr, param->min, param->max);
+
+ if (n != 4) {
+ _log("Could not parse custom parameter for '%s'!\n", opt->name);
+ free(param);
+ return NULL;
+ }
+
+ if (!strcmp(typestr, "curve"))
+ param->type = TYPE_CURVE;
+ else if (!strcmp(typestr, "invcurve"))
+ param->type = TYPE_INVCURVE;
+ else if (!strcmp(typestr, "int"))
+ param->type = TYPE_INT;
+ else if (!strcmp(typestr, "real"))
+ param->type = TYPE_FLOAT;
+ else if (!strcmp(typestr, "passcode"))
+ param->type = TYPE_PASSCODE;
+ else if (!strcmp(typestr, "password"))
+ param->type = TYPE_PASSWORD;
+ else if (!strcmp(typestr, "points"))
+ param->type = TYPE_POINTS;
+ else if (!strcmp(typestr, "string"))
+ param->type = TYPE_STRING;
+ else {
+ _log("Unknown custom parameter type for param '%s' for option '%s'\n", param->name, opt->name);
+ free(param);
+ return NULL;
+ }
+
+ param->next = NULL;
+
+ /* Insert param into opt->paramlist, sorted by order */
+ if (!opt->paramlist)
+ opt->paramlist = param;
+ else if (opt->paramlist->order > param->order) {
+ param->next = opt->paramlist;
+ opt->paramlist = param;
+ }
+ else {
+ for (p = opt->paramlist;
+ p->next && p->next->order < param->order;
+ p = p->next);
+ param->next = p->next;
+ p->next = param;
+ }
+
+ opt->param_count++;
+ return param;
+}
+
+param_t * option_assure_foomatic_param(option_t *opt)
+{
+ param_t *param;
+
+ if (opt->foomatic_param)
+ return opt->foomatic_param;
+
+ param = calloc(1, sizeof(param_t));
+ strcpy(param->name, "foomatic-param");
+ param->order = 0;
+ param->type = opt->type;
+
+ opt->foomatic_param = param;
+ return param;
+}
+
+
+/*
+ * Optionsets
+ */
+
+const char * optionset_name(int idx)
+{
+ if (idx < 0 || idx >= optionset_count) {
+ _log("Optionset with index %d does not exist\n", idx);
+ return NULL;
+ }
+ return optionsets[idx];
+}
+
+int optionset(const char * name)
+{
+ int i;
+
+ for (i = 0; i < optionset_count; i++) {
+ if (!strcmp(optionsets[i], name))
+ return i;
+ }
+
+ if (optionset_count == optionset_alloc) {
+ optionset_alloc *= 2;
+ optionsets = realloc(optionsets, optionset_alloc * sizeof(char *));
+ for (i = optionset_count; i < optionset_alloc; i++)
+ optionsets[i] = NULL;
+ }
+
+ optionsets[optionset_count] = strdup(name);
+ optionset_count++;
+ return optionset_count -1;
+}
+
+void optionset_copy_values(int src_optset, int dest_optset)
+{
+ option_t *opt;
+ value_t *val;
+
+ for (opt = optionlist; opt; opt = opt->next) {
+ for (val = opt->valuelist; val; val = val->next) {
+ if (val->optionset == src_optset) {
+ option_set_value(opt, dest_optset, val->value);
+ break;
+ }
+ }
+ }
+}
+
+void optionset_delete_values(int optionset)
+{
+ option_t *opt;
+ value_t *val, *prev_val;
+
+ for (opt = optionlist; opt; opt = opt->next) {
+ val = opt->valuelist;
+ prev_val = NULL;
+ while (val) {
+ if (val->optionset == optionset) {
+ if (prev_val)
+ prev_val->next = val->next;
+ else
+ opt->valuelist = val->next;
+ free_value(val);
+ val = prev_val ? prev_val->next : opt->valuelist;
+ break;
+ } else {
+ prev_val = val;
+ val = val->next;
+ }
+ }
+ }
+}
+
+int optionset_equal(int optset1, int optset2, int exceptPS)
+{
+ option_t *opt;
+ const char *val1, *val2;
+
+ for (opt = optionlist; opt; opt = opt->next) {
+ if (exceptPS && opt->style == 'G')
+ continue;
+
+ val1 = option_get_value(opt, optset1);
+ val2 = option_get_value(opt, optset2);
+
+ if (val1 && val2) { /* both entries exist */
+ if (strcmp(val1, val2) != 0)
+ return 0; /* but aren't equal */
+ }
+ else if (val1 || val2) /* one entry exists --> can't be equal */
+ return 0;
+ /* If no extry exists, the non-existing entries
+ * are considered as equal */
+ }
+ return 1;
+}
+
+/*
+ * read_ppd_file()
+ */
+void read_ppd_file(const char *filename)
+{
+ FILE *fh;
+ char line [256]; /* PPD line length is max 255 (excl. \0) */
+ char *p;
+ char key[128], name[64], text[64];
+ dstr_t *value = create_dstr(); /* value can span multiple lines */
+ double order;
+ value_t *val;
+ option_t *opt, *current_opt = NULL;
+ param_t *param;
+
+ fh = fopen(filename, "r");
+ if (!fh) {
+ _log("error opening %s\n", filename);
+ exit(EXIT_PRNERR_NORETRY_BAD_SETTINGS);
+ }
+ _log("Parsing PPD file ...\n");
+
+ dstrassure(value, 256);
+
+ while (!feof(fh)) {
+ fgets(line, 256, fh);
+
+ if (line[0] != '*' || startswith(line, "*%"))
+ continue;
+
+ /* get the key */
+ if (!(p = strchr(line, ':')))
+ continue;
+ *p = '\0';
+
+ key[0] = name[0] = text[0] = '\0';
+ sscanf(line, "*%127s%*[ \t]%63[^ \t/=)]%*1[/=]%63[^\n]", key, name, text);
+
+ /* get the value */
+ dstrclear(value);
+ sscanf(p +1, " %255[^\r\n]", value->data);
+ value->len = strlen(value->data);
+ if (!value->len)
+ _log("PPD: Missing value for key \"%s\"\n", line);
+
+ while (1) {
+ /* "&&" is the continue-on-next-line marker */
+ if (dstrendswith(value, "&&")) {
+ value->len -= 2;
+ value->data[value->len] = '\0';
+ }
+ /* quoted but quotes are not yet closed */
+ else if (value->data[0] == '\"' && !strchr(value->data +1, '\"'))
+ dstrcat(value, "\n"); /* keep newlines in quoted string*/
+ /* not quoted, or quotes already closed */
+ else
+ break;
+
+ fgets(line, 256, fh);
+ dstrcat(value, line);
+ dstrremovenewline(value);
+ }
+
+ /* remove quotes */
+ if (value->data[0] == '\"') {
+ memmove(value->data, value->data +1, value->len +1);
+ p = strrchr(value->data, '\"');
+ if (!p) {
+ _log("Invalid line: \"%s: ...\"\n", key);
+ continue;
+ }
+ *p = '\0';
+ }
+ /* remove last newline */
+ dstrremovenewline(value);
+
+ /* process key/value pairs */
+ if (strcmp(key, "NickName") == 0) {
+ unhtmlify(printer_model, 256, value->data);
+ }
+ else if (strcmp(key, "FoomaticIDs") == 0) {
+ /* *FoomaticIDs: <printer ID> <driver ID> */
+ sscanf(value->data, "%*[ \t]%127[^ \t]%*[ \t]%127[^ \t\n]",
+ printer_id, driver);
+ }
+ else if (strcmp(key, "FoomaticRIPPostPipe") == 0) {
+ if (!postpipe)
+ postpipe = create_dstr();
+ dstrassure(postpipe, value->len +128);
+ unhtmlify(postpipe->data, postpipe->alloc, value->data);
+ }
+ else if (strcmp(key, "FoomaticRIPCommandLine") == 0) {
+ unhtmlify(cmd, 1024, value->data);
+ }
+ else if (strcmp(key, "FoomaticRIPCommandLinePDF") == 0) {
+ unhtmlify(cmd_pdf, 1024, value->data);
+ }
+ else if (strcmp(key, "FoomaticNoPageAccounting") == 0) {
+ /* Boolean value */
+ if (strcasecmp(value->data, "true") != 0) {
+ /* Driver is not compatible with page accounting according to the
+ Foomatic database, so turn it off for this driver */
+ ps_accounting = 0;
+ _log("CUPS page accounting disabled by driver.\n");
+ }
+ }
+ else if (!strcmp(key, "cupsFilter")) {
+ /* cupsFilter: <code> */
+ /* only save the filter for "application/vnd.cups-raster" */
+ if (prefixcmp(value->data, "application/vnd.cups-raster") == 0) {
+ p = strrchr(value->data, ' ');
+ if (p)
+ unhtmlify(cupsfilter, 256, p +1);
+ }
+ }
+ else if (startswith(key, "Custom") && !strcasecmp(name, "true")) {
+ /* Cups custom option: *CustomFoo True: "command" */
+ if (startswith(&key[6], "JCL")) {
+ opt = assure_option(&key[9]);
+ opt->style = 'J';
+ }
+ else
+ opt = assure_option(&key[6]);
+ option_set_custom_command(opt, value->data);
+ if (!strcmp(key, "CustomPageSize"))
+ option_set_custom_command(assure_option("PageRegion"), value->data);
+ }
+ else if (startswith(key, "ParamCustom")) {
+ /* Cups custom parameter:
+ *ParamCustomFoo Name/Text: order type minimum maximum */
+ if (startswith(&key[11], "JCL"))
+ opt = assure_option(&key[14]);
+ else
+ opt = assure_option(&key[11]);
+ option_add_custom_param_from_string(opt, name, text, value->data);
+ }
+ else if (!strcmp(key, "OpenUI") || !strcmp(key, "JCLOpenUI")) {
+ /* "*[JCL]OpenUI *<option>[/<translation>]: <type>" */
+ current_opt = assure_option(&name[1]);
+ if (!isempty(text))
+ strlcpy(current_opt->text, text, 128);
+ if (startswith(key, "JCL"))
+ current_opt->style = 'J';
+ /* Set the argument type only if not defined yet,
+ a definition in "*FoomaticRIPOption" has priority */
+ if (current_opt->type == TYPE_NONE)
+ current_opt->type = type_from_string(value->data);
+ }
+ else if (!strcmp(key, "CloseUI") || !strcmp(key, "JCLCloseUI")) {
+ /* *[JCL]CloseUI: *<option> */
+ if (!current_opt || !option_has_name(current_opt, value->data +1))
+ _log("CloseUI found without corresponding OpenUI (%s).\n", value->data +1);
+ current_opt = NULL;
+ }
+ else if (!strcmp(key, "FoomaticRIPOption")) {
+ /* "*FoomaticRIPOption <option>: <type> <style> <spot> [<order>]"
+ <order> only used for 1-choice enum options */
+ option_set_from_string(assure_option(name), value->data);
+ }
+ else if (!strcmp(key, "FoomaticRIPOptionPrototype")) {
+ /* "*FoomaticRIPOptionPrototype <option>: <code>"
+ Used for numerical and string options only */
+ opt = assure_option(name);
+ opt->proto = malloc(128);
+ unhtmlify(opt->proto, 128, value->data);
+ }
+ else if (!strcmp(key, "FoomaticRIPOptionRange")) {
+ /* *FoomaticRIPOptionRange <option>: <min> <max>
+ Used for numerical options only */
+ param = option_assure_foomatic_param(assure_option(name));
+ sscanf(value->data, "%19s %19s", param->min, param->max);
+ }
+ else if (!strcmp(key, "FoomaticRIPOptionMaxLength")) {
+ /* "*FoomaticRIPOptionMaxLength <option>: <length>"
+ Used for string options only */
+ param = option_assure_foomatic_param(assure_option(name));
+ sscanf(value->data, "%19s", param->max);
+ }
+ else if (!strcmp(key, "FoomaticRIPOptionAllowedChars")) {
+ /* *FoomaticRIPOptionAllowedChars <option>: <code>
+ Used for string options only */
+ param = option_assure_foomatic_param(assure_option(name));
+ param_set_allowed_chars(param, value->data);
+ }
+ else if (!strcmp(key, "FoomaticRIPOptionAllowedRegExp")) {
+ /* "*FoomaticRIPOptionAllowedRegExp <option>: <code>"
+ Used for string options only */
+ param = option_assure_foomatic_param(assure_option(name));
+ param_set_allowed_regexp(param, value->data);
+ }
+ else if (!strcmp(key, "OrderDependency")) {
+ /* OrderDependency: <order> <section> *<option> */
+ /* use 'text' to read <section> */
+ sscanf(value->data, "%lf %63s *%63s", &order, text, name);
+ opt = assure_option(name);
+ opt->section = section_from_string(text);
+ option_set_order(opt, order);
+ }
+
+ /* Default options are not yet validated (not all options/choices
+ have been read yet) */
+ else if (!prefixcmp(key, "Default")) {
+ /* Default<option>: <value> */
+
+ /* TODO *DefaultColorSpace is a keyword and doesn't need to be extraced, does it? */
+ if (!strcmp(key, "DefaultColorSpace"))
+ continue;
+
+ opt = assure_option(&key[7]);
+ val = option_assure_value(opt, optionset("default"));
+ free(val->value);
+ val->value = strdup(value->data);
+ }
+ else if (!prefixcmp(key, "FoomaticRIPDefault")) {
+ /* FoomaticRIPDefault<option>: <value>
+ Used for numerical options only */
+ opt = assure_option(&key[18]);
+ val = option_assure_value(opt, optionset("default"));
+ free(val->value);
+ val->value = strdup(value->data);
+ }
+
+ /* Current argument */
+ else if (current_opt && !strcmp(key, current_opt->name)) {
+ /* *<option> <choice>[/translation]: <code> */
+ option_set_choice(current_opt, name, text, value->data);
+ }
+ else if (!strcmp(key, "FoomaticRIPOptionSetting")) {
+ /* "*FoomaticRIPOptionSetting <option>[=<choice>]: <code>
+ For boolean options <choice> is not given */
+ option_set_choice(assure_option(name),
+ isempty(text) ? "true" : text, NULL, value->data);
+ }
+
+ /* "*(Foomatic|)JCL(Begin|ToPSInterpreter|End|Prefix): <code>"
+ The printer supports PJL/JCL when there is such a line */
+ else if (!prefixcmp(key, "JCLBegin") ||
+ !prefixcmp(key, "FoomaticJCLBegin")) {
+ unhexify(jclbegin, 256, value->data);
+ if (!jclprefixset && strstr(jclbegin, "PJL") == NULL)
+ jclprefix[0] = '\0';
+ }
+ else if (!prefixcmp(key, "JCLToPSInterpreter") ||
+ !prefixcmp(key, "FoomaticJCLToPSInterpreter")) {
+ unhexify(jcltointerpreter, 256, value->data);
+ }
+ else if (!prefixcmp(key, "JCLEnd") ||
+ !prefixcmp(key, "FoomaticJCLEnd")) {
+ unhexify(jclend, 256, value->data);
+ }
+ else if (!prefixcmp(key, "JCLPrefix") ||
+ !prefixcmp(key, "FoomaticJCLPrefix")) {
+ unhexify(jclprefix, 256, value->data);
+ jclprefixset = 1;
+ }
+ else if (!prefixcmp(key, "% COMDATA #")) {
+ /* old foomtic 2.0.x PPD file */
+ _log("You are using an old Foomatic 2.0 PPD file, which is no "
+ "longer supported by Foomatic >4.0. Exiting.\n");
+ exit(1); /* TODO exit more gracefully */
+ }
+ }
+
+ fclose(fh);
+ free_dstr(value);
+
+ /* Validate default options by resetting them with option_set_value() */
+ for (opt = optionlist; opt; opt = opt->next) {
+ val = option_find_value(opt, optionset("default"));
+ if (val) {
+ /* if fromopt is set, this value has already been validated */
+ if (!val->fromoption)
+ option_set_value(opt, optionset("default"), val->value);
+ }
+ else
+ /* Make sure that this option has a default choice, even if none is
+ defined in the PPD file */
+ option_set_value(opt, optionset("default"), opt->choicelist->value);
+ }
+}
+
+int ppd_supports_pdf()
+{
+ option_t *opt;
+
+ /* If at least one option inserts PostScript code, we cannot support PDF */
+ for (opt = optionlist; opt; opt = opt->next)
+ {
+ choice_t *choice;
+
+ if (!option_is_ps_command(opt))
+ continue;
+
+ for (choice = opt->choicelist; choice; choice = choice->next)
+ if (contains_active_postscript(choice->command))
+ return 0;
+ }
+
+ if (!isempty(cmd_pdf))
+ return 1;
+
+ /* Ghostscript also accepts PDF, use that if it is in the normal command
+ * line */
+ if (startswith(cmd, "gs"))
+ {
+ strncpy(cmd_pdf, cmd, 1024);
+ return 1;
+ }
+
+ return 0;
+}
+
+/* build a renderer command line, based on the given option set */
+int build_commandline(int optset, dstr_t *cmdline, int pdfcmdline)
+{
+ option_t *opt;
+ const char *userval;
+ char *s, *p;
+ dstr_t *cmdvar = create_dstr();
+ dstr_t *open = create_dstr();
+ dstr_t *close = create_dstr();
+ char letters[] = "%A %B %C %D %E %F %G %H %I %J %K %L %M %W %X %Y %Z";
+ int jcl = 0;
+
+ dstr_t *local_jclprepend = create_dstr();
+
+ dstrclear(prologprepend);
+ dstrclear(setupprepend);
+ dstrclear(pagesetupprepend);
+
+ if (cmdline)
+ dstrcpy(cmdline, pdfcmdline ? cmd_pdf : cmd);
+
+ for (opt = optionlist_sorted_by_order; opt; opt = opt->next_by_order) {
+ /* composite options have no direct influence, and all their dependents
+ have already been set */
+ if (option_is_composite(opt))
+ continue;
+
+ userval = option_get_value(opt, optset);
+ option_get_command(cmdvar, opt, optset, -1);
+
+ /* Insert the built snippet at the correct place */
+ if (option_is_ps_command(opt)) {
+ /* Place this Postscript command onto the prepend queue
+ for the appropriate section. */
+ if (cmdvar->len) {
+ dstrcpyf(open, "[{\n%%%%BeginFeature: *%s ", opt->name);
+ if (opt->type == TYPE_BOOL)
+ dstrcatf(open, is_true_string(userval) ? "True\n" : "False\n");
+ else
+ dstrcatf(open, "%s\n", userval);
+ dstrcpyf(close, "\n%%%%EndFeature\n} stopped cleartomark\n");
+
+ switch (option_get_section(opt)) {
+ case SECTION_PROLOG:
+ dstrcatf(prologprepend, "%s%s%s", open->data, cmdvar->data, close->data);
+ break;
+
+ case SECTION_ANYSETUP:
+ if (optset != optionset("currentpage"))
+ dstrcatf(setupprepend, "%s%s%s", open->data, cmdvar->data, close->data);
+ else if (strcmp(option_get_value(opt, optionset("header")), userval) != 0)
+ dstrcatf(pagesetupprepend, "%s%s%s", open->data, cmdvar->data, close->data);
+ break;
+
+ case SECTION_DOCUMENTSETUP:
+ dstrcatf(setupprepend, "%s%s%s", open->data, cmdvar->data, close->data);
+ break;
+
+ case SECTION_PAGESETUP:
+ dstrcatf(pagesetupprepend, "%s%s%s", open->data, cmdvar->data, close->data);
+ break;
+
+ case SECTION_JCLSETUP: /* PCL/JCL argument */
+ s = malloc(cmdvar->len +1);
+ unhexify(s, cmdvar->len +1, cmdvar->data);
+ dstrcatf(local_jclprepend, "%s", s);
+ free(s);
+ break;
+
+ default:
+ dstrcatf(setupprepend, "%s%s%s", open->data, cmdvar->data, close->data);
+ }
+ }
+ }
+ else if (option_is_jcl_arg(opt)) {
+ jcl = 1;
+ /* Put JCL commands onto JCL stack */
+ if (cmdvar->len) {
+ char *s = malloc(cmdvar->len +1);
+ unhexify(s, cmdvar->len +1, cmdvar->data);
+ if (!startswith(cmdvar->data, jclprefix))
+ dstrcatf(local_jclprepend, "%s%s\n", jclprefix, s);
+ else
+ dstrcat(local_jclprepend, s);
+ free(s);
+ }
+ }
+ else if (option_is_commandline_arg(opt) && cmdline) {
+ /* Insert the processed argument in the command line
+ just before every occurrence of the spot marker. */
+ p = malloc(3);
+ snprintf(p, 3, "%%%c", opt->spot);
+ s = malloc(cmdvar->len +3);
+ snprintf(s, cmdvar->len +3, "%s%%%c", cmdvar->data, opt->spot);
+ dstrreplace(cmdline, p, s, 0);
+ free(p);
+ free(s);
+ }
+
+ /* Insert option into command line of CUPS raster driver */
+ if (cmdline && strstr(cmdline->data, "%Y")) {
+ if (isempty(userval))
+ continue;
+ s = malloc(strlen(opt->name) + strlen(userval) + 20);
+ sprintf(s, "%s=%s %%Y", opt->name, userval);
+ dstrreplace(cmdline, "%Y", s, 0);
+ free(s);
+ }
+ }
+
+ /* Tidy up after computing option statements for all of P, J, and C types: */
+
+ /* C type finishing */
+ /* Pluck out all of the %n's from the command line prototype */
+ if (cmdline) {
+ s = strtok(letters, " ");
+ do {
+ dstrreplace(cmdline, s, "", 0);
+ } while ((s = strtok(NULL, " ")));
+ }
+
+ /* J type finishing */
+ /* Compute the proper stuff to say around the job */
+ if (jcl && !jobhasjcl) {
+ /* command to switch to the interpreter */
+ dstrcatf(local_jclprepend, "%s", jcltointerpreter);
+
+ /* Arrange for JCL RESET command at the end of job */
+ dstrcpy(jclappend, jclend);
+
+ argv_free(jclprepend);
+ jclprepend = argv_split(local_jclprepend->data, "\r\n", NULL);
+ }
+
+ free_dstr(cmdvar);
+ free_dstr(open);
+ free_dstr(close);
+ free_dstr(local_jclprepend);
+
+ return !isempty(cmd);
+}
+
+/* if "comments" is set, add "%%BeginProlog...%%EndProlog" */
+void append_prolog_section(dstr_t *str, int optset, int comments)
+{
+ /* Start comment */
+ if (comments) {
+ _log("\"Prolog\" section is missing, inserting it.\n");
+ dstrcat(str, "%%BeginProlog\n");
+ }
+
+ /* Generate the option code (not necessary when CUPS is spooler and
+ PostScript data is not converted from PDF) */
+ if ((spooler != SPOOLER_CUPS) || pdfconvertedtops) {
+ _log("Inserting option code into \"Prolog\" section.\n");
+ build_commandline(optset, NULL, 0);
+ dstrcat(str, prologprepend->data);
+ }
+
+ /* End comment */
+ if (comments)
+ dstrcat(str, "%%EndProlog\n");
+}
+
+void append_setup_section(dstr_t *str, int optset, int comments)
+{
+ /* Start comment */
+ if (comments) {
+ _log("\"Setup\" section is missing, inserting it.\n");
+ dstrcat(str, "%%BeginSetup\n");
+ }
+
+ /* PostScript code to generate accounting messages for CUPS */
+ if (spooler == SPOOLER_CUPS) {
+ _log("Inserting PostScript code for CUPS' page accounting\n");
+ dstrcat(str, accounting_prolog);
+ }
+
+ /* Generate the option code (not necessary when CUPS is spooler and
+ PostScript data is not converted from PDF) */
+ if ((spooler != SPOOLER_CUPS) || pdfconvertedtops) {
+ _log("Inserting option code into \"Setup\" section.\n");
+ build_commandline(optset, NULL, 0);
+ dstrcat(str, setupprepend->data);
+ }
+
+ /* End comment */
+ if (comments)
+ dstrcat(str, "%%EndSetup\n");
+}
+
+void append_page_setup_section(dstr_t *str, int optset, int comments)
+{
+ /* Start comment */
+ if (comments) {
+ _log("\"PageSetup\" section is missing, inserting it.\n");
+ dstrcat(str, "%%BeginPageSetup\n");
+ }
+
+ /* Generate the option code (not necessary when CUPS is spooler) */
+ _log("Inserting option code into \"PageSetup\" section.\n");
+ build_commandline(optset, NULL, 0);
+ dstrcat(str, pagesetupprepend->data);
+
+ /* End comment */
+ if (comments)
+ dstrcat(str, "%%EndPageSetup\n");
+}
+
+
+typedef struct page_range {
+ short even, odd;
+ unsigned first, last;
+ struct page_range *next;
+} page_range_t;
+
+static page_range_t * parse_page_ranges(const char *ranges)
+{
+ page_range_t *head, *tail = NULL;
+ char *tokens, *tok;
+ int cnt;
+
+ tokens = strdup(ranges);
+ for (tok = strtok(tokens, ","); tok; tok = strtok(NULL, ",")) {
+ page_range_t *pr = calloc(1, sizeof(page_range_t));
+
+ if (startswith(tok, "even"))
+ pr->even = 1;
+ else if (startswith(tok, "odd"))
+ pr->odd = 1;
+ else if ((cnt = sscanf(tok, "%d-%d", &pr->first, &pr->last))) {
+ /* If 'last' has not been read, this could mean only one page (no
+ * hyphen) or all pages to the end */
+ if (cnt == 1 && !endswith(tok, "-"))
+ pr->last = pr->first;
+ else if (cnt == 2 && pr->first > pr->last) {
+ unsigned tmp = pr->first;
+ pr->first = pr->last;
+ pr->last = tmp;
+ }
+ }
+ else {
+ printf("Invalid page range: %s\n", tok);
+ free(pr);
+ continue;
+ }
+
+ if (tail) {
+ tail->next = pr;
+ tail = pr;
+ }
+ else
+ tail = head = pr;
+ }
+
+ free(tokens);
+ return head;
+}
+
+static void free_page_ranges(page_range_t *ranges)
+{
+ page_range_t *pr;
+ while (ranges) {
+ pr = ranges;
+ ranges = ranges->next;
+ free(pr);
+ }
+}
+
+/* Parse a string containing page ranges and either check whether a
+ given page is in the ranges or, if the given page number is zero,
+ determine the score how specific this page range string is.*/
+int get_page_score(const char *pages, int page)
+{
+ page_range_t *ranges = parse_page_ranges(pages);
+ page_range_t *pr;
+ int totalscore = 0;
+ int pageinside = 0;
+
+ for (pr = ranges; pr; pr = pr->next) {
+ if (pr->even) {
+ totalscore += 50000;
+ if (page % 2 == 0)
+ pageinside = 1;
+ }
+ else if (pr->odd) {
+ totalscore += 50000;
+ if (page % 2 == 1)
+ pageinside = 1;
+ }
+ else if (pr->first == pr->last) { /* Single page */
+ totalscore += 1;
+ if (page == pr->first)
+ pageinside = 1;
+ }
+ else if (pr->last == 0) { /* To the end of the document */
+ totalscore += 100000;
+ if (page >= pr->first)
+ pageinside = 1;
+ }
+ else { /* Sequence of pages */
+ totalscore += pr->last - pr->first +1;
+ if (page >= pr->first && page <= pr->last)
+ pageinside = 1;
+ }
+ }
+
+ free_page_ranges(ranges);
+
+ if (page == 0 || pageinside)
+ return totalscore;
+
+ return 0;
+}
+
+/* Set the options for a given page */
+void set_options_for_page(int optset, int page)
+{
+ int score, bestscore;
+ option_t *opt;
+ value_t *val, *bestvalue;
+ const char *ranges;
+ const char *optsetname;
+
+ for (opt = optionlist; opt; opt = opt->next) {
+
+ bestscore = 10000000;
+ bestvalue = NULL;
+ for (val = opt->valuelist; val; val = val->next) {
+
+ optsetname = optionset_name(val->optionset);
+ if (!startswith(optsetname, "pages:"))
+ continue;
+
+ ranges = &optsetname[6]; /* after "pages:" */
+ score = get_page_score(ranges, page);
+ if (score && score < bestscore) {
+ bestscore = score;
+ bestvalue = val;
+ }
+ }
+
+ if (bestvalue)
+ option_set_value(opt, optset, bestvalue->value);
+ }
+}
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-29 18:41:20 +0000