| /* |
| * Administration CGI for CUPS. |
| * |
| * 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 "cgi-private.h" |
| #include <cups/http-private.h> |
| #include <cups/ppd-private.h> |
| #include <cups/adminutil.h> |
| #include <cups/ppd.h> |
| #include <errno.h> |
| #include <unistd.h> |
| #include <fcntl.h> |
| #include <sys/wait.h> |
| #include <limits.h> |
| |
| |
| /* |
| * Local globals... |
| */ |
| |
| static int current_device = 0; /* Current device shown */ |
| |
| |
| /* |
| * Local functions... |
| */ |
| |
| static void choose_device_cb(const char *device_class, const char *device_id, const char *device_info, const char *device_make_and_model, const char *device_uri, const char *device_location, const char *title); |
| static void do_am_class(http_t *http, int modify); |
| static void do_am_printer(http_t *http, int modify); |
| static void do_config_server(http_t *http); |
| static void do_delete_class(http_t *http); |
| static void do_delete_printer(http_t *http); |
| static void do_list_printers(http_t *http); |
| static void do_menu(http_t *http); |
| static void do_set_allowed_users(http_t *http); |
| static void do_set_default(http_t *http); |
| static void do_set_options(http_t *http, int is_class); |
| static void do_set_sharing(http_t *http); |
| static char *get_option_value(ppd_file_t *ppd, const char *name, |
| char *buffer, size_t bufsize); |
| static double get_points(double number, const char *uval); |
| static char *get_printer_ppd(const char *uri, char *buffer, size_t bufsize); |
| |
| |
| /* |
| * 'main()' - Main entry for CGI. |
| */ |
| |
| int /* O - Exit status */ |
| main(void) |
| { |
| http_t *http; /* Connection to the server */ |
| const char *op; /* Operation name */ |
| |
| |
| /* |
| * Connect to the HTTP server... |
| */ |
| |
| fputs("DEBUG: admin.cgi started...\n", stderr); |
| |
| http = httpConnectEncrypt(cupsServer(), ippPort(), cupsEncryption()); |
| |
| if (!http) |
| { |
| perror("ERROR: Unable to connect to cupsd"); |
| fprintf(stderr, "DEBUG: cupsServer()=\"%s\"\n", |
| cupsServer() ? cupsServer() : "(null)"); |
| fprintf(stderr, "DEBUG: ippPort()=%d\n", ippPort()); |
| fprintf(stderr, "DEBUG: cupsEncryption()=%d\n", cupsEncryption()); |
| exit(1); |
| } |
| |
| fprintf(stderr, "DEBUG: http=%p\n", http); |
| |
| /* |
| * Set the web interface section... |
| */ |
| |
| cgiSetVariable("SECTION", "admin"); |
| cgiSetVariable("REFRESH_PAGE", ""); |
| |
| /* |
| * See if we have form data... |
| */ |
| |
| if (!cgiInitialize() || !cgiGetVariable("OP")) |
| { |
| /* |
| * Nope, send the administration menu... |
| */ |
| |
| fputs("DEBUG: No form data, showing main menu...\n", stderr); |
| |
| do_menu(http); |
| } |
| else if ((op = cgiGetVariable("OP")) != NULL && cgiIsPOST()) |
| { |
| /* |
| * Do the operation... |
| */ |
| |
| fprintf(stderr, "DEBUG: op=\"%s\"...\n", op); |
| |
| if (!*op) |
| { |
| const char *printer = getenv("PRINTER_NAME"), |
| /* Printer or class name */ |
| *server_port = getenv("SERVER_PORT"); |
| /* Port number string */ |
| int port = atoi(server_port ? server_port : "0"); |
| /* Port number */ |
| char uri[1024]; /* URL */ |
| |
| if (printer) |
| httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), |
| getenv("HTTPS") ? "https" : "http", NULL, |
| getenv("SERVER_NAME"), port, "/%s/%s", |
| cgiGetVariable("IS_CLASS") ? "classes" : "printers", |
| printer); |
| else |
| httpAssembleURI(HTTP_URI_CODING_ALL, uri, sizeof(uri), |
| getenv("HTTPS") ? "https" : "http", NULL, |
| getenv("SERVER_NAME"), port, "/admin"); |
| |
| printf("Location: %s\n\n", uri); |
| } |
| else if (!strcmp(op, "set-allowed-users")) |
| do_set_allowed_users(http); |
| else if (!strcmp(op, "set-as-default")) |
| do_set_default(http); |
| else if (!strcmp(op, "set-sharing")) |
| do_set_sharing(http); |
| else if (!strcmp(op, "find-new-printers") || |
| !strcmp(op, "list-available-printers")) |
| do_list_printers(http); |
| else if (!strcmp(op, "add-class")) |
| do_am_class(http, 0); |
| else if (!strcmp(op, "add-printer")) |
| do_am_printer(http, 0); |
| else if (!strcmp(op, "modify-class")) |
| do_am_class(http, 1); |
| else if (!strcmp(op, "modify-printer")) |
| do_am_printer(http, 1); |
| else if (!strcmp(op, "delete-class")) |
| do_delete_class(http); |
| else if (!strcmp(op, "delete-printer")) |
| do_delete_printer(http); |
| else if (!strcmp(op, "set-class-options")) |
| do_set_options(http, 1); |
| else if (!strcmp(op, "set-printer-options")) |
| do_set_options(http, 0); |
| else if (!strcmp(op, "config-server")) |
| do_config_server(http); |
| else |
| { |
| /* |
| * Bad operation code - display an error... |
| */ |
| |
| cgiStartHTML(cgiText(_("Administration"))); |
| cgiCopyTemplateLang("error-op.tmpl"); |
| cgiEndHTML(); |
| } |
| } |
| else if (op && !strcmp(op, "redirect")) |
| { |
| const char *url; /* Redirection URL... */ |
| char prefix[1024]; /* URL prefix */ |
| |
| |
| if (getenv("HTTPS")) |
| snprintf(prefix, sizeof(prefix), "https://%s:%s", |
| getenv("SERVER_NAME"), getenv("SERVER_PORT")); |
| else |
| snprintf(prefix, sizeof(prefix), "http://%s:%s", |
| getenv("SERVER_NAME"), getenv("SERVER_PORT")); |
| |
| fprintf(stderr, "DEBUG: redirecting with prefix %s!\n", prefix); |
| |
| if ((url = cgiGetVariable("URL")) != NULL) |
| { |
| char encoded[1024], /* Encoded URL string */ |
| *ptr; /* Pointer into encoded string */ |
| |
| |
| ptr = encoded; |
| if (*url != '/') |
| *ptr++ = '/'; |
| |
| for (; *url && ptr < (encoded + sizeof(encoded) - 4); url ++) |
| { |
| if (strchr("%@&+ <>#=", *url) || *url < ' ' || *url & 128) |
| { |
| /* |
| * Percent-encode this character; safe because we have at least 4 |
| * bytes left in the array... |
| */ |
| |
| sprintf(ptr, "%%%02X", *url & 255); |
| ptr += 3; |
| } |
| else |
| *ptr++ = *url; |
| } |
| |
| *ptr = '\0'; |
| |
| if (*url) |
| { |
| /* |
| * URL was too long, just redirect to the admin page... |
| */ |
| |
| printf("Location: %s/admin\n\n", prefix); |
| } |
| else |
| { |
| /* |
| * URL is OK, redirect there... |
| */ |
| |
| printf("Location: %s%s\n\n", prefix, encoded); |
| } |
| } |
| else |
| printf("Location: %s/admin\n\n", prefix); |
| } |
| else |
| { |
| /* |
| * Form data but no operation code - display an error... |
| */ |
| |
| cgiStartHTML(cgiText(_("Administration"))); |
| cgiCopyTemplateLang("error-op.tmpl"); |
| cgiEndHTML(); |
| } |
| |
| /* |
| * Close the HTTP server connection... |
| */ |
| |
| httpClose(http); |
| |
| /* |
| * Return with no errors... |
| */ |
| |
| return (0); |
| } |
| |
| |
| /* |
| * 'choose_device_cb()' - Add a device to the device selection page. |
| */ |
| |
| static void |
| choose_device_cb( |
| const char *device_class, /* I - Class */ |
| const char *device_id, /* I - 1284 device ID */ |
| const char *device_info, /* I - Description */ |
| const char *device_make_and_model, /* I - Make and model */ |
| const char *device_uri, /* I - Device URI */ |
| const char *device_location, /* I - Location */ |
| const char *title) /* I - Page title */ |
| { |
| /* |
| * For modern browsers, start a multi-part page so we can show that something |
| * is happening. Non-modern browsers just get everything at the end... |
| */ |
| |
| if (current_device == 0 && cgiSupportsMultipart()) |
| { |
| cgiStartMultipart(); |
| cgiStartHTML(title); |
| cgiCopyTemplateLang("choose-device.tmpl"); |
| cgiEndHTML(); |
| fflush(stdout); |
| } |
| |
| |
| /* |
| * Add the device to the array... |
| */ |
| |
| cgiSetArray("device_class", current_device, device_class); |
| cgiSetArray("device_id", current_device, device_id); |
| cgiSetArray("device_info", current_device, device_info); |
| cgiSetArray("device_make_and_model", current_device, device_make_and_model); |
| cgiSetArray("device_uri", current_device, device_uri); |
| cgiSetArray("device_location", current_device, device_location); |
| |
| current_device ++; |
| } |
| |
| |
| /* |
| * 'do_am_class()' - Add or modify a class. |
| */ |
| |
| static void |
| do_am_class(http_t *http, /* I - HTTP connection */ |
| int modify) /* I - Modify the printer? */ |
| { |
| int i, j; /* Looping vars */ |
| int element; /* Element number */ |
| int num_printers; /* Number of printers */ |
| ipp_t *request, /* IPP request */ |
| *response; /* IPP response */ |
| ipp_attribute_t *attr; /* member-uris attribute */ |
| char uri[HTTP_MAX_URI]; /* Device or printer URI */ |
| const char *name, /* Pointer to class name */ |
| *op, /* Operation name */ |
| *ptr; /* Pointer to CGI variable */ |
| const char *title; /* Title of page */ |
| static const char * const pattrs[] = /* Requested printer attributes */ |
| { |
| "member-names", |
| "printer-info", |
| "printer-location" |
| }; |
| |
| |
| title = cgiText(modify ? _("Modify Class") : _("Add Class")); |
| op = cgiGetVariable("OP"); |
| name = cgiGetVariable("PRINTER_NAME"); |
| |
| if (cgiGetVariable("PRINTER_LOCATION") == NULL) |
| { |
| /* |
| * Build a CUPS_GET_PRINTERS request, which requires the |
| * following attributes: |
| * |
| * attributes-charset |
| * attributes-natural-language |
| */ |
| |
| request = ippNewRequest(CUPS_GET_PRINTERS); |
| |
| ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_ENUM, "printer-type", |
| CUPS_PRINTER_LOCAL); |
| ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_ENUM, "printer-type-mask", |
| CUPS_PRINTER_CLASS | CUPS_PRINTER_REMOTE); |
| |
| /* |
| * Do the request and get back a response... |
| */ |
| |
| cgiClearVariables(); |
| if (op) |
| cgiSetVariable("OP", op); |
| if (name) |
| cgiSetVariable("PRINTER_NAME", name); |
| |
| if ((response = cupsDoRequest(http, request, "/")) != NULL) |
| { |
| /* |
| * Create MEMBER_URIS and MEMBER_NAMES arrays... |
| */ |
| |
| for (element = 0, attr = response->attrs; |
| attr != NULL; |
| attr = attr->next) |
| if (attr->name && !strcmp(attr->name, "printer-uri-supported")) |
| { |
| if ((ptr = strrchr(attr->values[0].string.text, '/')) != NULL && |
| (!name || _cups_strcasecmp(name, ptr + 1))) |
| { |
| /* |
| * Don't show the current class... |
| */ |
| |
| cgiSetArray("MEMBER_URIS", element, attr->values[0].string.text); |
| element ++; |
| } |
| } |
| |
| for (element = 0, attr = response->attrs; |
| attr != NULL; |
| attr = attr->next) |
| if (attr->name && !strcmp(attr->name, "printer-name")) |
| { |
| if (!name || _cups_strcasecmp(name, attr->values[0].string.text)) |
| { |
| /* |
| * Don't show the current class... |
| */ |
| |
| cgiSetArray("MEMBER_NAMES", element, attr->values[0].string.text); |
| element ++; |
| } |
| } |
| |
| num_printers = cgiGetSize("MEMBER_URIS"); |
| |
| ippDelete(response); |
| } |
| else |
| num_printers = 0; |
| |
| if (modify) |
| { |
| /* |
| * Build an IPP_GET_PRINTER_ATTRIBUTES request, which requires the |
| * following attributes: |
| * |
| * attributes-charset |
| * attributes-natural-language |
| * printer-uri |
| */ |
| |
| request = ippNewRequest(IPP_GET_PRINTER_ATTRIBUTES); |
| |
| httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL, |
| "localhost", 0, "/classes/%s", name); |
| ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", |
| NULL, uri); |
| |
| ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, |
| "requested-attributes", |
| (int)(sizeof(pattrs) / sizeof(pattrs[0])), |
| NULL, pattrs); |
| |
| /* |
| * Do the request and get back a response... |
| */ |
| |
| if ((response = cupsDoRequest(http, request, "/")) != NULL) |
| { |
| if ((attr = ippFindAttribute(response, "member-names", |
| IPP_TAG_NAME)) != NULL) |
| { |
| /* |
| * Mark any current members in the class... |
| */ |
| |
| for (j = 0; j < num_printers; j ++) |
| cgiSetArray("MEMBER_SELECTED", j, ""); |
| |
| for (i = 0; i < attr->num_values; i ++) |
| { |
| for (j = 0; j < num_printers; j ++) |
| { |
| if (!_cups_strcasecmp(attr->values[i].string.text, |
| cgiGetArray("MEMBER_NAMES", j))) |
| { |
| cgiSetArray("MEMBER_SELECTED", j, "SELECTED"); |
| break; |
| } |
| } |
| } |
| } |
| |
| if ((attr = ippFindAttribute(response, "printer-info", |
| IPP_TAG_TEXT)) != NULL) |
| cgiSetVariable("PRINTER_INFO", attr->values[0].string.text); |
| |
| if ((attr = ippFindAttribute(response, "printer-location", |
| IPP_TAG_TEXT)) != NULL) |
| cgiSetVariable("PRINTER_LOCATION", attr->values[0].string.text); |
| |
| ippDelete(response); |
| } |
| |
| /* |
| * Update the location and description of an existing printer... |
| */ |
| |
| cgiStartHTML(title); |
| cgiCopyTemplateLang("modify-class.tmpl"); |
| } |
| else |
| { |
| /* |
| * Get the name, location, and description for a new printer... |
| */ |
| |
| cgiStartHTML(title); |
| cgiCopyTemplateLang("add-class.tmpl"); |
| } |
| |
| cgiEndHTML(); |
| |
| return; |
| } |
| |
| if (!name) |
| { |
| cgiStartHTML(title); |
| cgiSetVariable("ERROR", cgiText(_("Missing form variable"))); |
| cgiCopyTemplateLang("error.tmpl"); |
| cgiEndHTML(); |
| return; |
| } |
| |
| for (ptr = name; *ptr; ptr ++) |
| if ((*ptr >= 0 && *ptr <= ' ') || *ptr == 127 || *ptr == '/' || *ptr == '#') |
| break; |
| |
| if (*ptr || ptr == name || strlen(name) > 127) |
| { |
| cgiSetVariable("ERROR", |
| cgiText(_("The class name may only contain up to " |
| "127 printable characters and may not " |
| "contain spaces, slashes (/), or the " |
| "pound sign (#)."))); |
| cgiStartHTML(title); |
| cgiCopyTemplateLang("error.tmpl"); |
| cgiEndHTML(); |
| return; |
| } |
| |
| /* |
| * Build a CUPS_ADD_CLASS request, which requires the following |
| * attributes: |
| * |
| * attributes-charset |
| * attributes-natural-language |
| * printer-uri |
| * printer-location |
| * printer-info |
| * printer-is-accepting-jobs |
| * printer-state |
| * member-uris |
| */ |
| |
| request = ippNewRequest(CUPS_ADD_CLASS); |
| |
| httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL, |
| "localhost", 0, "/classes/%s", name); |
| ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", |
| NULL, uri); |
| |
| ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_TEXT, "printer-location", |
| NULL, cgiGetVariable("PRINTER_LOCATION")); |
| |
| ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_TEXT, "printer-info", |
| NULL, cgiGetVariable("PRINTER_INFO")); |
| |
| ippAddBoolean(request, IPP_TAG_PRINTER, "printer-is-accepting-jobs", 1); |
| |
| ippAddInteger(request, IPP_TAG_PRINTER, IPP_TAG_ENUM, "printer-state", |
| IPP_PRINTER_IDLE); |
| |
| if ((num_printers = cgiGetSize("MEMBER_URIS")) > 0) |
| { |
| attr = ippAddStrings(request, IPP_TAG_PRINTER, IPP_TAG_URI, "member-uris", |
| num_printers, NULL, NULL); |
| for (i = 0; i < num_printers; i ++) |
| ippSetString(request, &attr, i, cgiGetArray("MEMBER_URIS", i)); |
| } |
| |
| /* |
| * Do the request and get back a response... |
| */ |
| |
| ippDelete(cupsDoRequest(http, request, "/admin/")); |
| |
| if (cupsLastError() == IPP_NOT_AUTHORIZED) |
| { |
| puts("Status: 401\n"); |
| exit(0); |
| } |
| else if (cupsLastError() > IPP_OK_CONFLICT) |
| { |
| cgiStartHTML(title); |
| cgiShowIPPError(modify ? _("Unable to modify class") : |
| _("Unable to add class")); |
| } |
| else |
| { |
| /* |
| * Redirect successful updates back to the class page... |
| */ |
| |
| char refresh[1024]; /* Refresh URL */ |
| |
| cgiFormEncode(uri, name, sizeof(uri)); |
| snprintf(refresh, sizeof(refresh), "5;URL=/admin/?OP=redirect&URL=/classes/%s", |
| uri); |
| cgiSetVariable("refresh_page", refresh); |
| |
| cgiStartHTML(title); |
| |
| if (modify) |
| cgiCopyTemplateLang("class-modified.tmpl"); |
| else |
| cgiCopyTemplateLang("class-added.tmpl"); |
| } |
| |
| cgiEndHTML(); |
| } |
| |
| |
| /* |
| * 'do_am_printer()' - Add or modify a printer. |
| */ |
| |
| static void |
| do_am_printer(http_t *http, /* I - HTTP connection */ |
| int modify) /* I - Modify the printer? */ |
| { |
| int i; /* Looping var */ |
| ipp_attribute_t *attr; /* Current attribute */ |
| ipp_t *request, /* IPP request */ |
| *response, /* IPP response */ |
| *oldinfo; /* Old printer information */ |
| const cgi_file_t *file; /* Uploaded file, if any */ |
| const char *var; /* CGI variable */ |
| char uri[HTTP_MAX_URI], /* Device or printer URI */ |
| *uriptr, /* Pointer into URI */ |
| evefile[1024] = ""; /* IPP Everywhere PPD file */ |
| int maxrate; /* Maximum baud rate */ |
| char baudrate[255]; /* Baud rate string */ |
| const char *name, /* Pointer to class name */ |
| *ptr; /* Pointer to CGI variable */ |
| const char *title; /* Title of page */ |
| static int baudrates[] = /* Baud rates */ |
| { |
| 1200, |
| 2400, |
| 4800, |
| 9600, |
| 19200, |
| 38400, |
| 57600, |
| 115200, |
| 230400, |
| 460800 |
| }; |
| |
| |
| ptr = cgiGetVariable("DEVICE_URI"); |
| fprintf(stderr, "DEBUG: do_am_printer: DEVICE_URI=\"%s\"\n", |
| ptr ? ptr : "(null)"); |
| |
| title = cgiText(modify ? _("Modify Printer") : _("Add Printer")); |
| |
| if (modify) |
| { |
| /* |
| * Build an IPP_GET_PRINTER_ATTRIBUTES request, which requires the |
| * following attributes: |
| * |
| * attributes-charset |
| * attributes-natural-language |
| * printer-uri |
| */ |
| |
| request = ippNewRequest(IPP_GET_PRINTER_ATTRIBUTES); |
| |
| httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL, |
| "localhost", 0, "/printers/%s", |
| cgiGetVariable("PRINTER_NAME")); |
| ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", |
| NULL, uri); |
| |
| /* |
| * Do the request and get back a response... |
| */ |
| |
| oldinfo = cupsDoRequest(http, request, "/"); |
| } |
| else |
| oldinfo = NULL; |
| |
| file = cgiGetFile(); |
| |
| if (file) |
| { |
| fprintf(stderr, "DEBUG: file->tempfile=%s\n", file->tempfile); |
| fprintf(stderr, "DEBUG: file->name=%s\n", file->name); |
| fprintf(stderr, "DEBUG: file->filename=%s\n", file->filename); |
| fprintf(stderr, "DEBUG: file->mimetype=%s\n", file->mimetype); |
| } |
| |
| if ((name = cgiGetVariable("PRINTER_NAME")) != NULL) |
| { |
| for (ptr = name; *ptr; ptr ++) |
| if ((*ptr >= 0 && *ptr <= ' ') || *ptr == 127 || *ptr == '/' || *ptr == '\\' || *ptr == '?' || *ptr == '\'' || *ptr == '\"' || *ptr == '#') |
| break; |
| |
| if (*ptr || ptr == name || strlen(name) > 127) |
| { |
| cgiSetVariable("ERROR", |
| cgiText(_("The printer name may only contain up to 127 printable characters and may not contain spaces, slashes (/ \\), quotes (' \"), question mark (?), or the pound sign (#)."))); |
| cgiStartHTML(title); |
| cgiCopyTemplateLang("error.tmpl"); |
| cgiEndHTML(); |
| return; |
| } |
| } |
| |
| if ((var = cgiGetVariable("DEVICE_URI")) != NULL) |
| { |
| if ((uriptr = strrchr(var, '|')) != NULL) |
| { |
| /* |
| * Extract make and make/model from device URI string... |
| */ |
| |
| char make[1024], /* Make string */ |
| *makeptr; /* Pointer into make */ |
| |
| |
| *uriptr++ = '\0'; |
| |
| strlcpy(make, uriptr, sizeof(make)); |
| |
| if ((makeptr = strchr(make, ' ')) != NULL) |
| *makeptr = '\0'; |
| else if ((makeptr = strchr(make, '-')) != NULL) |
| *makeptr = '\0'; |
| else if (!_cups_strncasecmp(make, "laserjet", 8) || |
| !_cups_strncasecmp(make, "deskjet", 7) || |
| !_cups_strncasecmp(make, "designjet", 9)) |
| strlcpy(make, "HP", sizeof(make)); |
| else if (!_cups_strncasecmp(make, "phaser", 6)) |
| strlcpy(make, "Xerox", sizeof(make)); |
| else if (!_cups_strncasecmp(make, "stylus", 6)) |
| strlcpy(make, "Epson", sizeof(make)); |
| else |
| strlcpy(make, "Generic", sizeof(make)); |
| |
| if (!cgiGetVariable("CURRENT_MAKE")) |
| cgiSetVariable("CURRENT_MAKE", make); |
| |
| if (!cgiGetVariable("CURRENT_MAKE_AND_MODEL")) |
| cgiSetVariable("CURRENT_MAKE_AND_MODEL", uriptr); |
| |
| if (!modify) |
| { |
| char template[128], /* Template name */ |
| *tptr; /* Pointer into template name */ |
| |
| cgiSetVariable("PRINTER_INFO", uriptr); |
| |
| for (tptr = template; |
| tptr < (template + sizeof(template) - 1) && *uriptr; |
| uriptr ++) |
| if (isalnum(*uriptr & 255) || *uriptr == '_' || *uriptr == '-' || |
| *uriptr == '.') |
| *tptr++ = *uriptr; |
| else if ((*uriptr == ' ' || *uriptr == '/') && tptr > template && |
| tptr[-1] != '_') |
| *tptr++ = '_'; |
| else if (*uriptr == '?' || *uriptr == '(') |
| break; |
| |
| *tptr = '\0'; |
| |
| cgiSetVariable("TEMPLATE_NAME", template); |
| } |
| } |
| } |
| |
| if (!var) |
| { |
| /* |
| * Look for devices so the user can pick something... |
| */ |
| |
| if ((attr = ippFindAttribute(oldinfo, "device-uri", IPP_TAG_URI)) != NULL) |
| { |
| strlcpy(uri, attr->values[0].string.text, sizeof(uri)); |
| if ((uriptr = strchr(uri, ':')) != NULL && strncmp(uriptr, "://", 3) == 0) |
| *uriptr = '\0'; |
| |
| cgiSetVariable("CURRENT_DEVICE_URI", attr->values[0].string.text); |
| cgiSetVariable("CURRENT_DEVICE_SCHEME", uri); |
| } |
| |
| /* |
| * Scan for devices for up to 30 seconds... |
| */ |
| |
| fputs("DEBUG: Getting list of devices...\n", stderr); |
| |
| current_device = 0; |
| if (cupsGetDevices(http, 5, CUPS_INCLUDE_ALL, CUPS_EXCLUDE_NONE, |
| (cups_device_cb_t)choose_device_cb, |
| (void *)title) == IPP_OK) |
| { |
| fputs("DEBUG: Got device list!\n", stderr); |
| |
| if (cgiSupportsMultipart()) |
| cgiStartMultipart(); |
| |
| cgiSetVariable("CUPS_GET_DEVICES_DONE", "1"); |
| cgiStartHTML(title); |
| cgiCopyTemplateLang("choose-device.tmpl"); |
| cgiEndHTML(); |
| |
| if (cgiSupportsMultipart()) |
| cgiEndMultipart(); |
| } |
| else |
| { |
| fprintf(stderr, |
| "ERROR: CUPS-Get-Devices request failed with status %x: %s\n", |
| cupsLastError(), cupsLastErrorString()); |
| if (cupsLastError() == IPP_NOT_AUTHORIZED) |
| { |
| puts("Status: 401\n"); |
| exit(0); |
| } |
| else |
| { |
| cgiStartHTML(title); |
| cgiShowIPPError(modify ? _("Unable to modify printer") : |
| _("Unable to add printer")); |
| cgiEndHTML(); |
| return; |
| } |
| } |
| } |
| else if (!strchr(var, '/') || |
| (!strncmp(var, "lpd://", 6) && !strchr(var + 6, '/'))) |
| { |
| if ((attr = ippFindAttribute(oldinfo, "device-uri", IPP_TAG_URI)) != NULL) |
| { |
| /* |
| * Set the current device URI for the form to the old one... |
| */ |
| |
| if (strncmp(attr->values[0].string.text, var, strlen(var)) == 0) |
| cgiSetVariable("CURRENT_DEVICE_URI", attr->values[0].string.text); |
| } |
| |
| /* |
| * User needs to set the full URI... |
| */ |
| |
| cgiStartHTML(title); |
| cgiCopyTemplateLang("choose-uri.tmpl"); |
| cgiEndHTML(); |
| } |
| else if (!strncmp(var, "serial:", 7) && !cgiGetVariable("BAUDRATE")) |
| { |
| /* |
| * Need baud rate, parity, etc. |
| */ |
| |
| if ((var = strchr(var, '?')) != NULL && |
| strncmp(var, "?baud=", 6) == 0) |
| maxrate = atoi(var + 6); |
| else |
| maxrate = 19200; |
| |
| for (i = 0; i < 10; i ++) |
| if (baudrates[i] > maxrate) |
| break; |
| else |
| { |
| sprintf(baudrate, "%d", baudrates[i]); |
| cgiSetArray("BAUDRATES", i, baudrate); |
| } |
| |
| cgiStartHTML(title); |
| cgiCopyTemplateLang("choose-serial.tmpl"); |
| cgiEndHTML(); |
| } |
| else if (!name || !cgiGetVariable("PRINTER_LOCATION")) |
| { |
| cgiStartHTML(title); |
| |
| if (modify) |
| { |
| /* |
| * Update the location and description of an existing printer... |
| */ |
| |
| if (oldinfo) |
| { |
| if ((attr = ippFindAttribute(oldinfo, "printer-info", |
| IPP_TAG_TEXT)) != NULL) |
| cgiSetVariable("PRINTER_INFO", attr->values[0].string.text); |
| |
| if ((attr = ippFindAttribute(oldinfo, "printer-location", |
| IPP_TAG_TEXT)) != NULL) |
| cgiSetVariable("PRINTER_LOCATION", attr->values[0].string.text); |
| |
| if ((attr = ippFindAttribute(oldinfo, "printer-is-shared", |
| IPP_TAG_BOOLEAN)) != NULL) |
| cgiSetVariable("PRINTER_IS_SHARED", |
| attr->values[0].boolean ? "1" : "0"); |
| } |
| |
| cgiCopyTemplateLang("modify-printer.tmpl"); |
| } |
| else |
| { |
| /* |
| * Get the name, location, and description for a new printer... |
| */ |
| |
| #ifdef __APPLE__ |
| if (!strncmp(var, "usb:", 4)) |
| cgiSetVariable("printer_is_shared", "1"); |
| else |
| #endif /* __APPLE__ */ |
| cgiSetVariable("printer_is_shared", "0"); |
| |
| cgiCopyTemplateLang("add-printer.tmpl"); |
| } |
| |
| cgiEndHTML(); |
| |
| if (oldinfo) |
| ippDelete(oldinfo); |
| |
| return; |
| } |
| else if (!file && |
| (!cgiGetVariable("PPD_NAME") || cgiGetVariable("SELECT_MAKE"))) |
| { |
| int ipp_everywhere = !strncmp(var, "ipp://", 6) || !strncmp(var, "ipps://", 7) || (!strncmp(var, "dnssd://", 8) && (strstr(var, "_ipp._tcp") || strstr(var, "_ipps._tcp"))); |
| |
| if (modify && !cgiGetVariable("SELECT_MAKE")) |
| { |
| /* |
| * Get the PPD file... |
| */ |
| |
| int fd; /* PPD file */ |
| char filename[1024]; /* PPD filename */ |
| ppd_file_t *ppd; /* PPD information */ |
| char buffer[1024]; /* Buffer */ |
| ssize_t bytes; /* Number of bytes */ |
| http_status_t get_status; /* Status of GET */ |
| |
| |
| /* TODO: Use cupsGetFile() API... */ |
| snprintf(uri, sizeof(uri), "/printers/%s.ppd", name); |
| |
| if (httpGet(http, uri)) |
| httpGet(http, uri); |
| |
| while ((get_status = httpUpdate(http)) == HTTP_CONTINUE); |
| |
| if (get_status != HTTP_OK) |
| { |
| httpFlush(http); |
| |
| fprintf(stderr, "ERROR: Unable to get PPD file %s: %d - %s\n", |
| uri, get_status, httpStatus(get_status)); |
| } |
| else if ((fd = cupsTempFd(filename, sizeof(filename))) >= 0) |
| { |
| while ((bytes = httpRead2(http, buffer, sizeof(buffer))) > 0) |
| write(fd, buffer, (size_t)bytes); |
| |
| close(fd); |
| |
| if ((ppd = ppdOpenFile(filename)) != NULL) |
| { |
| if (ppd->manufacturer) |
| cgiSetVariable("CURRENT_MAKE", ppd->manufacturer); |
| |
| if (ppd->nickname) |
| cgiSetVariable("CURRENT_MAKE_AND_MODEL", ppd->nickname); |
| |
| ppdClose(ppd); |
| unlink(filename); |
| } |
| else |
| { |
| int linenum; /* Line number */ |
| |
| fprintf(stderr, "ERROR: Unable to open PPD file %s: %s\n", |
| filename, ppdErrorString(ppdLastError(&linenum))); |
| } |
| } |
| else |
| { |
| httpFlush(http); |
| |
| fprintf(stderr, |
| "ERROR: Unable to create temporary file for PPD file: %s\n", |
| strerror(errno)); |
| } |
| } |
| |
| /* |
| * Build a CUPS_GET_PPDS request, which requires the following |
| * attributes: |
| * |
| * attributes-charset |
| * attributes-natural-language |
| * printer-uri |
| */ |
| |
| request = ippNewRequest(CUPS_GET_PPDS); |
| |
| ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", |
| NULL, "ipp://localhost/printers/"); |
| |
| if ((var = cgiGetVariable("PPD_MAKE")) == NULL) |
| var = cgiGetVariable("CURRENT_MAKE"); |
| if (var && !cgiGetVariable("SELECT_MAKE")) |
| { |
| const char *make_model; /* Make and model */ |
| |
| |
| ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_TEXT, |
| "ppd-make", NULL, var); |
| |
| if ((make_model = cgiGetVariable("CURRENT_MAKE_AND_MODEL")) != NULL) |
| ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_TEXT, |
| "ppd-make-and-model", NULL, make_model); |
| } |
| else |
| ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, |
| "requested-attributes", NULL, "ppd-make"); |
| |
| /* |
| * Do the request and get back a response... |
| */ |
| |
| if ((response = cupsDoRequest(http, request, "/")) != NULL) |
| { |
| /* |
| * Got the list of PPDs, see if the user has selected a make... |
| */ |
| |
| if (cgiSetIPPVars(response, NULL, NULL, NULL, 0) == 0 && !modify) |
| { |
| /* |
| * No PPD files with this make, try again with all makes... |
| */ |
| |
| ippDelete(response); |
| |
| request = ippNewRequest(CUPS_GET_PPDS); |
| |
| ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", |
| NULL, "ipp://localhost/printers/"); |
| |
| ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, |
| "requested-attributes", NULL, "ppd-make"); |
| |
| if ((response = cupsDoRequest(http, request, "/")) != NULL) |
| cgiSetIPPVars(response, NULL, NULL, NULL, 0); |
| |
| cgiStartHTML(title); |
| cgiCopyTemplateLang("choose-make.tmpl"); |
| cgiEndHTML(); |
| } |
| else if (!var || cgiGetVariable("SELECT_MAKE")) |
| { |
| cgiStartHTML(title); |
| cgiCopyTemplateLang("choose-make.tmpl"); |
| cgiEndHTML(); |
| } |
| else |
| { |
| /* |
| * Let the user choose a model... |
| */ |
| |
| cgiStartHTML(title); |
| if (!cgiGetVariable("PPD_MAKE")) |
| cgiSetVariable("PPD_MAKE", cgiGetVariable("CURRENT_MAKE")); |
| if (ipp_everywhere) |
| cgiSetVariable("SHOW_IPP_EVERYWHERE", "1"); |
| cgiCopyTemplateLang("choose-model.tmpl"); |
| cgiEndHTML(); |
| } |
| |
| ippDelete(response); |
| } |
| else |
| { |
| cgiStartHTML(title); |
| cgiShowIPPError(_("Unable to get list of printer drivers")); |
| cgiCopyTemplateLang("error.tmpl"); |
| cgiEndHTML(); |
| } |
| } |
| else |
| { |
| /* |
| * Build a CUPS_ADD_PRINTER request, which requires the following |
| * attributes: |
| * |
| * attributes-charset |
| * attributes-natural-language |
| * printer-uri |
| * printer-location |
| * printer-info |
| * ppd-name |
| * device-uri |
| * printer-is-accepting-jobs |
| * printer-is-shared |
| * printer-state |
| */ |
| |
| request = ippNewRequest(CUPS_ADD_PRINTER); |
| |
| httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL, |
| "localhost", 0, "/printers/%s", |
| cgiGetVariable("PRINTER_NAME")); |
| ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", |
| NULL, uri); |
| |
| if (!file) |
| { |
| var = cgiGetVariable("PPD_NAME"); |
| if (!strcmp(var, "everywhere")) |
| get_printer_ppd(cgiGetVariable("DEVICE_URI"), evefile, sizeof(evefile)); |
| else if (strcmp(var, "__no_change__")) |
| ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "ppd-name", |
| NULL, var); |
| } |
| |
| ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_TEXT, "printer-location", |
| NULL, cgiGetVariable("PRINTER_LOCATION")); |
| |
| ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_TEXT, "printer-info", |
| NULL, cgiGetVariable("PRINTER_INFO")); |
| |
| strlcpy(uri, cgiGetVariable("DEVICE_URI"), sizeof(uri)); |
| |
| /* |
| * Strip make and model from URI... |
| */ |
| |
| if ((uriptr = strrchr(uri, '|')) != NULL) |
| *uriptr = '\0'; |
| |
| if (!strncmp(uri, "serial:", 7)) |
| { |
| /* |
| * Update serial port URI to include baud rate, etc. |
| */ |
| |
| if ((uriptr = strchr(uri, '?')) == NULL) |
| uriptr = uri + strlen(uri); |
| |
| snprintf(uriptr, sizeof(uri) - (size_t)(uriptr - uri), |
| "?baud=%s+bits=%s+parity=%s+flow=%s", |
| cgiGetVariable("BAUDRATE"), cgiGetVariable("BITS"), |
| cgiGetVariable("PARITY"), cgiGetVariable("FLOW")); |
| } |
| |
| ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_URI, "device-uri", |
| NULL, uri); |
| |
| ippAddBoolean(request, IPP_TAG_PRINTER, "printer-is-accepting-jobs", 1); |
| |
| var = cgiGetVariable("printer_is_shared"); |
| ippAddBoolean(request, IPP_TAG_PRINTER, "printer-is-shared", |
| var && (!strcmp(var, "1") || !strcmp(var, "on"))); |
| |
| ippAddInteger(request, IPP_TAG_PRINTER, IPP_TAG_ENUM, "printer-state", |
| IPP_PRINTER_IDLE); |
| |
| /* |
| * Do the request and get back a response... |
| */ |
| |
| if (file) |
| ippDelete(cupsDoFileRequest(http, request, "/admin/", file->tempfile)); |
| else if (evefile[0]) |
| { |
| ippDelete(cupsDoFileRequest(http, request, "/admin/", evefile)); |
| unlink(evefile); |
| } |
| else |
| ippDelete(cupsDoRequest(http, request, "/admin/")); |
| |
| if (cupsLastError() == IPP_NOT_AUTHORIZED) |
| { |
| puts("Status: 401\n"); |
| exit(0); |
| } |
| else if (cupsLastError() > IPP_OK_CONFLICT) |
| { |
| cgiStartHTML(title); |
| cgiShowIPPError(modify ? _("Unable to modify printer") : |
| _("Unable to add printer")); |
| } |
| else if (modify) |
| { |
| /* |
| * Redirect successful updates back to the printer page... |
| */ |
| |
| char refresh[1024]; /* Refresh URL */ |
| |
| |
| cgiFormEncode(uri, name, sizeof(uri)); |
| |
| snprintf(refresh, sizeof(refresh), |
| "5;/admin/?OP=redirect&URL=/printers/%s", uri); |
| |
| cgiSetVariable("refresh_page", refresh); |
| |
| cgiStartHTML(title); |
| |
| cgiCopyTemplateLang("printer-modified.tmpl"); |
| } |
| else |
| { |
| /* |
| * Set the printer options... |
| */ |
| |
| cgiSetVariable("OP", "set-printer-options"); |
| do_set_options(http, 0); |
| return; |
| } |
| |
| cgiEndHTML(); |
| } |
| |
| if (oldinfo) |
| ippDelete(oldinfo); |
| } |
| |
| |
| /* |
| * 'do_config_server()' - Configure server settings. |
| */ |
| |
| static void |
| do_config_server(http_t *http) /* I - HTTP connection */ |
| { |
| if (cgiGetVariable("CHANGESETTINGS")) |
| { |
| /* |
| * Save basic setting changes... |
| */ |
| |
| int num_settings; /* Number of server settings */ |
| cups_option_t *settings; /* Server settings */ |
| int advanced, /* Advanced settings shown? */ |
| changed; /* Have settings changed? */ |
| const char *debug_logging, /* DEBUG_LOGGING value */ |
| *preserve_jobs = NULL, |
| /* PRESERVE_JOBS value */ |
| *remote_admin, /* REMOTE_ADMIN value */ |
| *remote_any, /* REMOTE_ANY value */ |
| *share_printers,/* SHARE_PRINTERS value */ |
| *user_cancel_any, |
| /* USER_CANCEL_ANY value */ |
| *browse_web_if = NULL, |
| /* BrowseWebIF value */ |
| *preserve_job_history = NULL, |
| /* PreserveJobHistory value */ |
| *preserve_job_files = NULL, |
| /* PreserveJobFiles value */ |
| *max_clients = NULL, |
| /* MaxClients value */ |
| *max_jobs = NULL, |
| /* MaxJobs value */ |
| *max_log_size = NULL; |
| /* MaxLogSize value */ |
| const char *current_browse_web_if, |
| /* BrowseWebIF value */ |
| *current_preserve_job_history, |
| /* PreserveJobHistory value */ |
| *current_preserve_job_files, |
| /* PreserveJobFiles value */ |
| *current_max_clients, |
| /* MaxClients value */ |
| *current_max_jobs, |
| /* MaxJobs value */ |
| *current_max_log_size; |
| /* MaxLogSize value */ |
| #ifdef HAVE_GSSAPI |
| char default_auth_type[255]; |
| /* DefaultAuthType value */ |
| const char *val; /* Setting value */ |
| #endif /* HAVE_GSSAPI */ |
| |
| |
| /* |
| * Get the checkbox values from the form... |
| */ |
| |
| debug_logging = cgiGetVariable("DEBUG_LOGGING") ? "1" : "0"; |
| remote_admin = cgiGetVariable("REMOTE_ADMIN") ? "1" : "0"; |
| remote_any = cgiGetVariable("REMOTE_ANY") ? "1" : "0"; |
| share_printers = cgiGetVariable("SHARE_PRINTERS") ? "1" : "0"; |
| user_cancel_any = cgiGetVariable("USER_CANCEL_ANY") ? "1" : "0"; |
| |
| advanced = cgiGetVariable("ADVANCEDSETTINGS") != NULL; |
| if (advanced) |
| { |
| /* |
| * Get advanced settings... |
| */ |
| |
| browse_web_if = cgiGetVariable("BROWSE_WEB_IF") ? "Yes" : "No"; |
| max_clients = cgiGetVariable("MAX_CLIENTS"); |
| max_log_size = cgiGetVariable("MAX_LOG_SIZE"); |
| preserve_jobs = cgiGetVariable("PRESERVE_JOBS"); |
| |
| if (preserve_jobs) |
| { |
| max_jobs = cgiGetVariable("MAX_JOBS"); |
| preserve_job_history = cgiGetVariable("PRESERVE_JOB_HISTORY"); |
| preserve_job_files = cgiGetVariable("PRESERVE_JOB_FILES"); |
| |
| if (!max_jobs || atoi(max_jobs) < 0) |
| max_jobs = "500"; |
| |
| if (!preserve_job_history) |
| preserve_job_history = "On"; |
| |
| if (!preserve_job_files) |
| preserve_job_files = "1d"; |
| } |
| else |
| { |
| max_jobs = "0"; |
| preserve_job_history = "No"; |
| preserve_job_files = "No"; |
| } |
| |
| if (!max_clients || atoi(max_clients) <= 0) |
| max_clients = "100"; |
| |
| if (!max_log_size || atoi(max_log_size) <= 0.0) |
| max_log_size = "1m"; |
| } |
| |
| /* |
| * Get the current server settings... |
| */ |
| |
| if (!cupsAdminGetServerSettings(http, &num_settings, &settings)) |
| { |
| cgiStartHTML(cgiText(_("Change Settings"))); |
| cgiSetVariable("MESSAGE", |
| cgiText(_("Unable to change server settings"))); |
| cgiSetVariable("ERROR", cupsLastErrorString()); |
| cgiCopyTemplateLang("error.tmpl"); |
| cgiEndHTML(); |
| return; |
| } |
| |
| #ifdef HAVE_GSSAPI |
| /* |
| * Get authentication settings... |
| */ |
| |
| if (cgiGetVariable("KERBEROS")) |
| strlcpy(default_auth_type, "Negotiate", sizeof(default_auth_type)); |
| else |
| { |
| val = cupsGetOption("DefaultAuthType", num_settings, settings); |
| |
| if (!val || !_cups_strcasecmp(val, "Negotiate")) |
| strlcpy(default_auth_type, "Basic", sizeof(default_auth_type)); |
| else |
| strlcpy(default_auth_type, val, sizeof(default_auth_type)); |
| } |
| |
| fprintf(stderr, "DEBUG: DefaultAuthType %s\n", default_auth_type); |
| #endif /* HAVE_GSSAPI */ |
| |
| if ((current_browse_web_if = cupsGetOption("BrowseWebIF", num_settings, |
| settings)) == NULL) |
| current_browse_web_if = "No"; |
| |
| if ((current_preserve_job_history = cupsGetOption("PreserveJobHistory", |
| num_settings, |
| settings)) == NULL) |
| current_preserve_job_history = "Yes"; |
| |
| if ((current_preserve_job_files = cupsGetOption("PreserveJobFiles", |
| num_settings, |
| settings)) == NULL) |
| current_preserve_job_files = "1d"; |
| |
| if ((current_max_clients = cupsGetOption("MaxClients", num_settings, |
| settings)) == NULL) |
| current_max_clients = "100"; |
| |
| if ((current_max_jobs = cupsGetOption("MaxJobs", num_settings, |
| settings)) == NULL) |
| current_max_jobs = "500"; |
| |
| if ((current_max_log_size = cupsGetOption("MaxLogSize", num_settings, |
| settings)) == NULL) |
| current_max_log_size = "1m"; |
| |
| /* |
| * See if the settings have changed... |
| */ |
| |
| changed = strcmp(debug_logging, cupsGetOption(CUPS_SERVER_DEBUG_LOGGING, |
| num_settings, settings)) || |
| strcmp(remote_admin, cupsGetOption(CUPS_SERVER_REMOTE_ADMIN, |
| num_settings, settings)) || |
| strcmp(remote_any, cupsGetOption(CUPS_SERVER_REMOTE_ANY, |
| num_settings, settings)) || |
| strcmp(share_printers, cupsGetOption(CUPS_SERVER_SHARE_PRINTERS, |
| num_settings, settings)) || |
| #ifdef HAVE_GSSAPI |
| !cupsGetOption("DefaultAuthType", num_settings, settings) || |
| strcmp(default_auth_type, cupsGetOption("DefaultAuthType", |
| num_settings, settings)) || |
| #endif /* HAVE_GSSAPI */ |
| strcmp(user_cancel_any, cupsGetOption(CUPS_SERVER_USER_CANCEL_ANY, |
| num_settings, settings)); |
| |
| if (advanced && !changed) |
| changed = _cups_strcasecmp(browse_web_if, current_browse_web_if) || |
| _cups_strcasecmp(preserve_job_history, current_preserve_job_history) || |
| _cups_strcasecmp(preserve_job_files, current_preserve_job_files) || |
| _cups_strcasecmp(max_clients, current_max_clients) || |
| _cups_strcasecmp(max_jobs, current_max_jobs) || |
| _cups_strcasecmp(max_log_size, current_max_log_size); |
| |
| if (changed) |
| { |
| /* |
| * Settings *have* changed, so save the changes... |
| */ |
| |
| cupsFreeOptions(num_settings, settings); |
| |
| num_settings = 0; |
| num_settings = cupsAddOption(CUPS_SERVER_DEBUG_LOGGING, |
| debug_logging, num_settings, &settings); |
| num_settings = cupsAddOption(CUPS_SERVER_REMOTE_ADMIN, |
| remote_admin, num_settings, &settings); |
| num_settings = cupsAddOption(CUPS_SERVER_REMOTE_ANY, |
| remote_any, num_settings, &settings); |
| num_settings = cupsAddOption(CUPS_SERVER_SHARE_PRINTERS, |
| share_printers, num_settings, &settings); |
| num_settings = cupsAddOption(CUPS_SERVER_USER_CANCEL_ANY, |
| user_cancel_any, num_settings, &settings); |
| #ifdef HAVE_GSSAPI |
| num_settings = cupsAddOption("DefaultAuthType", default_auth_type, |
| num_settings, &settings); |
| #endif /* HAVE_GSSAPI */ |
| |
| if (advanced) |
| { |
| /* |
| * Add advanced settings... |
| */ |
| |
| if (_cups_strcasecmp(browse_web_if, current_browse_web_if)) |
| num_settings = cupsAddOption("BrowseWebIF", browse_web_if, |
| num_settings, &settings); |
| if (_cups_strcasecmp(preserve_job_history, current_preserve_job_history)) |
| num_settings = cupsAddOption("PreserveJobHistory", |
| preserve_job_history, num_settings, |
| &settings); |
| if (_cups_strcasecmp(preserve_job_files, current_preserve_job_files)) |
| num_settings = cupsAddOption("PreserveJobFiles", preserve_job_files, |
| num_settings, &settings); |
| if (_cups_strcasecmp(max_clients, current_max_clients)) |
| num_settings = cupsAddOption("MaxClients", max_clients, num_settings, |
| &settings); |
| if (_cups_strcasecmp(max_jobs, current_max_jobs)) |
| num_settings = cupsAddOption("MaxJobs", max_jobs, num_settings, |
| &settings); |
| if (_cups_strcasecmp(max_log_size, current_max_log_size)) |
| num_settings = cupsAddOption("MaxLogSize", max_log_size, num_settings, |
| &settings); |
| } |
| |
| if (!cupsAdminSetServerSettings(http, num_settings, settings)) |
| { |
| if (cupsLastError() == IPP_NOT_AUTHORIZED) |
| { |
| puts("Status: 401\n"); |
| exit(0); |
| } |
| |
| cgiStartHTML(cgiText(_("Change Settings"))); |
| cgiSetVariable("MESSAGE", |
| cgiText(_("Unable to change server settings"))); |
| cgiSetVariable("ERROR", cupsLastErrorString()); |
| cgiCopyTemplateLang("error.tmpl"); |
| } |
| else |
| { |
| if (advanced) |
| cgiSetVariable("refresh_page", "5;URL=/admin/?OP=redirect&" |
| "URL=/admin/?ADVANCEDSETTINGS=YES"); |
| else |
| cgiSetVariable("refresh_page", "5;URL=/admin/?OP=redirect"); |
| cgiStartHTML(cgiText(_("Change Settings"))); |
| cgiCopyTemplateLang("restart.tmpl"); |
| } |
| } |
| else |
| { |
| /* |
| * No changes... |
| */ |
| |
| cgiSetVariable("refresh_page", "5;URL=/admin/?OP=redirect"); |
| cgiStartHTML(cgiText(_("Change Settings"))); |
| cgiCopyTemplateLang("norestart.tmpl"); |
| } |
| |
| cupsFreeOptions(num_settings, settings); |
| |
| cgiEndHTML(); |
| } |
| else if (cgiGetVariable("SAVECHANGES") && cgiGetVariable("CUPSDCONF")) |
| { |
| /* |
| * Save hand-edited config file... |
| */ |
| |
| http_status_t status; /* PUT status */ |
| char tempfile[1024]; /* Temporary new cupsd.conf */ |
| int tempfd; /* Temporary file descriptor */ |
| cups_file_t *temp; /* Temporary file */ |
| const char *start, /* Start of line */ |
| *end; /* End of line */ |
| |
| |
| /* |
| * Create a temporary file for the new cupsd.conf file... |
| */ |
| |
| if ((tempfd = cupsTempFd(tempfile, sizeof(tempfile))) < 0) |
| { |
| cgiStartHTML(cgiText(_("Edit Configuration File"))); |
| cgiSetVariable("MESSAGE", cgiText(_("Unable to create temporary file"))); |
| cgiSetVariable("ERROR", strerror(errno)); |
| cgiCopyTemplateLang("error.tmpl"); |
| cgiEndHTML(); |
| |
| perror(tempfile); |
| return; |
| } |
| |
| if ((temp = cupsFileOpenFd(tempfd, "w")) == NULL) |
| { |
| cgiStartHTML(cgiText(_("Edit Configuration File"))); |
| cgiSetVariable("MESSAGE", cgiText(_("Unable to create temporary file"))); |
| cgiSetVariable("ERROR", strerror(errno)); |
| cgiCopyTemplateLang("error.tmpl"); |
| cgiEndHTML(); |
| |
| perror(tempfile); |
| close(tempfd); |
| unlink(tempfile); |
| return; |
| } |
| |
| /* |
| * Copy the cupsd.conf text from the form variable... |
| */ |
| |
| start = cgiGetVariable("CUPSDCONF"); |
| while (start) |
| { |
| if ((end = strstr(start, "\r\n")) == NULL) |
| if ((end = strstr(start, "\n")) == NULL) |
| end = start + strlen(start); |
| |
| cupsFileWrite(temp, start, (size_t)(end - start)); |
| cupsFilePutChar(temp, '\n'); |
| |
| if (*end == '\r') |
| start = end + 2; |
| else if (*end == '\n') |
| start = end + 1; |
| else |
| start = NULL; |
| } |
| |
| cupsFileClose(temp); |
| |
| /* |
| * Upload the configuration file to the server... |
| */ |
| |
| status = cupsPutFile(http, "/admin/conf/cupsd.conf", tempfile); |
| |
| if (status == HTTP_UNAUTHORIZED) |
| { |
| puts("Status: 401\n"); |
| unlink(tempfile); |
| exit(0); |
| } |
| else if (status != HTTP_CREATED) |
| { |
| cgiSetVariable("MESSAGE", |
| cgiText(_("Unable to upload cupsd.conf file"))); |
| cgiSetVariable("ERROR", httpStatus(status)); |
| |
| cgiStartHTML(cgiText(_("Edit Configuration File"))); |
| cgiCopyTemplateLang("error.tmpl"); |
| } |
| else |
| { |
| cgiSetVariable("refresh_page", "5;URL=/admin/"); |
| |
| cgiStartHTML(cgiText(_("Edit Configuration File"))); |
| cgiCopyTemplateLang("restart.tmpl"); |
| } |
| |
| cgiEndHTML(); |
| |
| unlink(tempfile); |
| } |
| else |
| { |
| struct stat info; /* cupsd.conf information */ |
| cups_file_t *cupsd; /* cupsd.conf file */ |
| char *buffer, /* Buffer for entire file */ |
| *bufptr, /* Pointer into buffer */ |
| *bufend; /* End of buffer */ |
| int ch; /* Character from file */ |
| char filename[1024]; /* Filename */ |
| const char *server_root; /* Location of config files */ |
| |
| |
| /* |
| * Locate the cupsd.conf file... |
| */ |
| |
| if ((server_root = getenv("CUPS_SERVERROOT")) == NULL) |
| server_root = CUPS_SERVERROOT; |
| |
| snprintf(filename, sizeof(filename), "%s/cupsd.conf", server_root); |
| |
| /* |
| * Figure out the size... |
| */ |
| |
| if (stat(filename, &info)) |
| { |
| cgiStartHTML(cgiText(_("Edit Configuration File"))); |
| cgiSetVariable("MESSAGE", |
| cgiText(_("Unable to access cupsd.conf file"))); |
| cgiSetVariable("ERROR", strerror(errno)); |
| cgiCopyTemplateLang("error.tmpl"); |
| cgiEndHTML(); |
| |
| perror(filename); |
| return; |
| } |
| |
| if (info.st_size > (1024 * 1024)) |
| { |
| cgiStartHTML(cgiText(_("Edit Configuration File"))); |
| cgiSetVariable("MESSAGE", |
| cgiText(_("Unable to access cupsd.conf file"))); |
| cgiSetVariable("ERROR", |
| cgiText(_("Unable to edit cupsd.conf files larger than " |
| "1MB"))); |
| cgiCopyTemplateLang("error.tmpl"); |
| cgiEndHTML(); |
| |
| fprintf(stderr, "ERROR: \"%s\" too large (%ld) to edit!\n", filename, |
| (long)info.st_size); |
| return; |
| } |
| |
| /* |
| * Open the cupsd.conf file... |
| */ |
| |
| if ((cupsd = cupsFileOpen(filename, "r")) == NULL) |
| { |
| /* |
| * Unable to open - log an error... |
| */ |
| |
| cgiStartHTML(cgiText(_("Edit Configuration File"))); |
| cgiSetVariable("MESSAGE", |
| cgiText(_("Unable to access cupsd.conf file"))); |
| cgiSetVariable("ERROR", strerror(errno)); |
| cgiCopyTemplateLang("error.tmpl"); |
| cgiEndHTML(); |
| |
| perror(filename); |
| return; |
| } |
| |
| /* |
| * Allocate memory and load the file into a string buffer... |
| */ |
| |
| if ((buffer = calloc(1, (size_t)info.st_size + 1)) != NULL) |
| { |
| cupsFileRead(cupsd, buffer, (size_t)info.st_size); |
| cgiSetVariable("CUPSDCONF", buffer); |
| free(buffer); |
| } |
| |
| cupsFileClose(cupsd); |
| |
| /* |
| * Then get the default cupsd.conf file and put that into a string as |
| * well... |
| */ |
| |
| strlcat(filename, ".default", sizeof(filename)); |
| |
| if (!stat(filename, &info) && info.st_size < (1024 * 1024) && |
| (cupsd = cupsFileOpen(filename, "r")) != NULL) |
| { |
| if ((buffer = calloc(1, 2 * (size_t)info.st_size + 1)) != NULL) |
| { |
| bufend = buffer + 2 * info.st_size - 1; |
| |
| for (bufptr = buffer; |
| bufptr < bufend && (ch = cupsFileGetChar(cupsd)) != EOF;) |
| { |
| if (ch == '\\' || ch == '\"') |
| { |
| *bufptr++ = '\\'; |
| *bufptr++ = (char)ch; |
| } |
| else if (ch == '\n') |
| { |
| *bufptr++ = '\\'; |
| *bufptr++ = 'n'; |
| } |
| else if (ch == '\t') |
| { |
| *bufptr++ = '\\'; |
| *bufptr++ = 't'; |
| } |
| else if (ch >= ' ') |
| *bufptr++ = (char)ch; |
| } |
| |
| *bufptr = '\0'; |
| |
| cgiSetVariable("CUPSDCONF_DEFAULT", buffer); |
| free(buffer); |
| } |
| |
| cupsFileClose(cupsd); |
| } |
| |
| /* |
| * Show the current config file... |
| */ |
| |
| cgiStartHTML(cgiText(_("Edit Configuration File"))); |
| |
| cgiCopyTemplateLang("edit-config.tmpl"); |
| |
| cgiEndHTML(); |
| } |
| } |
| |
| |
| /* |
| * 'do_delete_class()' - Delete a class. |
| */ |
| |
| static void |
| do_delete_class(http_t *http) /* I - HTTP connection */ |
| { |
| ipp_t *request; /* IPP request */ |
| char uri[HTTP_MAX_URI]; /* Job URI */ |
| const char *pclass; /* Printer class name */ |
| |
| |
| /* |
| * Get form variables... |
| */ |
| |
| if (cgiGetVariable("CONFIRM") == NULL) |
| { |
| cgiStartHTML(cgiText(_("Delete Class"))); |
| cgiCopyTemplateLang("class-confirm.tmpl"); |
| cgiEndHTML(); |
| return; |
| } |
| |
| if ((pclass = cgiGetVariable("PRINTER_NAME")) != NULL) |
| httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL, |
| "localhost", 0, "/classes/%s", pclass); |
| else |
| { |
| cgiStartHTML(cgiText(_("Delete Class"))); |
| cgiSetVariable("ERROR", cgiText(_("Missing form variable"))); |
| cgiCopyTemplateLang("error.tmpl"); |
| cgiEndHTML(); |
| return; |
| } |
| |
| /* |
| * Build a CUPS_DELETE_CLASS request, which requires the following |
| * attributes: |
| * |
| * attributes-charset |
| * attributes-natural-language |
| * printer-uri |
| */ |
| |
| request = ippNewRequest(CUPS_DELETE_CLASS); |
| |
| ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", |
| NULL, uri); |
| |
| /* |
| * Do the request and get back a response... |
| */ |
| |
| ippDelete(cupsDoRequest(http, request, "/admin/")); |
| |
| /* |
| * Show the results... |
| */ |
| |
| if (cupsLastError() == IPP_NOT_AUTHORIZED) |
| { |
| puts("Status: 401\n"); |
| exit(0); |
| } |
| else if (cupsLastError() <= IPP_OK_CONFLICT) |
| { |
| /* |
| * Redirect successful updates back to the classes page... |
| */ |
| |
| cgiSetVariable("refresh_page", "5;URL=/admin/?OP=redirect&URL=/classes"); |
| } |
| |
| cgiStartHTML(cgiText(_("Delete Class"))); |
| |
| if (cupsLastError() > IPP_OK_CONFLICT) |
| cgiShowIPPError(_("Unable to delete class")); |
| else |
| cgiCopyTemplateLang("class-deleted.tmpl"); |
| |
| cgiEndHTML(); |
| } |
| |
| |
| /* |
| * 'do_delete_printer()' - Delete a printer. |
| */ |
| |
| static void |
| do_delete_printer(http_t *http) /* I - HTTP connection */ |
| { |
| ipp_t *request; /* IPP request */ |
| char uri[HTTP_MAX_URI]; /* Job URI */ |
| const char *printer; /* Printer printer name */ |
| |
| |
| /* |
| * Get form variables... |
| */ |
| |
| if (cgiGetVariable("CONFIRM") == NULL) |
| { |
| cgiStartHTML(cgiText(_("Delete Printer"))); |
| cgiCopyTemplateLang("printer-confirm.tmpl"); |
| cgiEndHTML(); |
| return; |
| } |
| |
| if ((printer = cgiGetVariable("PRINTER_NAME")) != NULL) |
| httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL, |
| "localhost", 0, "/printers/%s", printer); |
| else |
| { |
| cgiStartHTML(cgiText(_("Delete Printer"))); |
| cgiSetVariable("ERROR", cgiText(_("Missing form variable"))); |
| cgiCopyTemplateLang("error.tmpl"); |
| cgiEndHTML(); |
| return; |
| } |
| |
| /* |
| * Build a CUPS_DELETE_PRINTER request, which requires the following |
| * attributes: |
| * |
| * attributes-charset |
| * attributes-natural-language |
| * printer-uri |
| */ |
| |
| request = ippNewRequest(CUPS_DELETE_PRINTER); |
| |
| ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", |
| NULL, uri); |
| |
| /* |
| * Do the request and get back a response... |
| */ |
| |
| ippDelete(cupsDoRequest(http, request, "/admin/")); |
| |
| /* |
| * Show the results... |
| */ |
| |
| if (cupsLastError() == IPP_NOT_AUTHORIZED) |
| { |
| puts("Status: 401\n"); |
| exit(0); |
| } |
| else if (cupsLastError() <= IPP_OK_CONFLICT) |
| { |
| /* |
| * Redirect successful updates back to the printers page... |
| */ |
| |
| cgiSetVariable("refresh_page", "5;URL=/admin/?OP=redirect&URL=/printers"); |
| } |
| |
| cgiStartHTML(cgiText(_("Delete Printer"))); |
| |
| if (cupsLastError() > IPP_OK_CONFLICT) |
| cgiShowIPPError(_("Unable to delete printer")); |
| else |
| cgiCopyTemplateLang("printer-deleted.tmpl"); |
| |
| cgiEndHTML(); |
| } |
| |
| |
| /* |
| * 'do_list_printers()' - List available printers. |
| */ |
| |
| static void |
| do_list_printers(http_t *http) /* I - HTTP connection */ |
| { |
| ipp_t *request, /* IPP request */ |
| *response; /* IPP response */ |
| ipp_attribute_t *attr; /* IPP attribute */ |
| |
| |
| cgiStartHTML(cgiText(_("List Available Printers"))); |
| fflush(stdout); |
| |
| /* |
| * Get the list of printers and their devices... |
| */ |
| |
| request = ippNewRequest(CUPS_GET_PRINTERS); |
| |
| ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, |
| "requested-attributes", NULL, "device-uri"); |
| |
| ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_ENUM, "printer-type", |
| CUPS_PRINTER_LOCAL); |
| ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_ENUM, "printer-type-mask", |
| CUPS_PRINTER_LOCAL); |
| |
| if ((response = cupsDoRequest(http, request, "/")) != NULL) |
| { |
| /* |
| * Got the printer list, now load the devices... |
| */ |
| |
| int i; /* Looping var */ |
| cups_array_t *printer_devices; /* Printer devices for local printers */ |
| char *printer_device; /* Current printer device */ |
| |
| |
| /* |
| * Allocate an array and copy the device strings... |
| */ |
| |
| printer_devices = cupsArrayNew((cups_array_func_t)strcmp, NULL); |
| |
| for (attr = ippFindAttribute(response, "device-uri", IPP_TAG_URI); |
| attr; |
| attr = ippFindNextAttribute(response, "device-uri", IPP_TAG_URI)) |
| { |
| cupsArrayAdd(printer_devices, strdup(attr->values[0].string.text)); |
| } |
| |
| /* |
| * Free the printer list and get the device list... |
| */ |
| |
| ippDelete(response); |
| |
| request = ippNewRequest(CUPS_GET_DEVICES); |
| |
| if ((response = cupsDoRequest(http, request, "/")) != NULL) |
| { |
| /* |
| * Got the device list, let's parse it... |
| */ |
| |
| const char *device_uri, /* device-uri attribute value */ |
| *device_make_and_model, /* device-make-and-model value */ |
| *device_info; /* device-info value */ |
| |
| |
| for (i = 0, attr = response->attrs; attr; attr = attr->next) |
| { |
| /* |
| * Skip leading attributes until we hit a device... |
| */ |
| |
| while (attr && attr->group_tag != IPP_TAG_PRINTER) |
| attr = attr->next; |
| |
| if (!attr) |
| break; |
| |
| /* |
| * Pull the needed attributes from this device... |
| */ |
| |
| device_info = NULL; |
| device_make_and_model = NULL; |
| device_uri = NULL; |
| |
| while (attr && attr->group_tag == IPP_TAG_PRINTER) |
| { |
| if (!strcmp(attr->name, "device-info") && |
| attr->value_tag == IPP_TAG_TEXT) |
| device_info = attr->values[0].string.text; |
| |
| if (!strcmp(attr->name, "device-make-and-model") && |
| attr->value_tag == IPP_TAG_TEXT) |
| device_make_and_model = attr->values[0].string.text; |
| |
| if (!strcmp(attr->name, "device-uri") && |
| attr->value_tag == IPP_TAG_URI) |
| device_uri = attr->values[0].string.text; |
| |
| attr = attr->next; |
| } |
| |
| /* |
| * See if we have everything needed... |
| */ |
| |
| if (device_info && device_make_and_model && device_uri && |
| _cups_strcasecmp(device_make_and_model, "unknown") && |
| strchr(device_uri, ':')) |
| { |
| /* |
| * Yes, now see if there is already a printer for this |
| * device... |
| */ |
| |
| if (!cupsArrayFind(printer_devices, (void *)device_uri)) |
| { |
| /* |
| * Not found, so it must be a new printer... |
| */ |
| |
| char option[1024], /* Form variables for this device */ |
| *option_ptr; /* Pointer into string */ |
| const char *ptr; /* Pointer into device string */ |
| |
| |
| /* |
| * Format the printer name variable for this device... |
| * |
| * We use the device-info string first, then device-uri, |
| * and finally device-make-and-model to come up with a |
| * suitable name. |
| */ |
| |
| if (_cups_strncasecmp(device_info, "unknown", 7)) |
| ptr = device_info; |
| else if ((ptr = strstr(device_uri, "://")) != NULL) |
| ptr += 3; |
| else |
| ptr = device_make_and_model; |
| |
| for (option_ptr = option; |
| option_ptr < (option + sizeof(option) - 1) && *ptr; |
| ptr ++) |
| if (isalnum(*ptr & 255) || *ptr == '_' || *ptr == '-' || |
| *ptr == '.') |
| *option_ptr++ = *ptr; |
| else if ((*ptr == ' ' || *ptr == '/') && option_ptr > option && |
| option_ptr[-1] != '_') |
| *option_ptr++ = '_'; |
| else if (*ptr == '?' || *ptr == '(') |
| break; |
| |
| *option_ptr = '\0'; |
| |
| cgiSetArray("TEMPLATE_NAME", i, option); |
| |
| /* |
| * Finally, set the form variables for this printer... |
| */ |
| |
| cgiSetArray("device_info", i, device_info); |
| cgiSetArray("device_make_and_model", i, device_make_and_model); |
| cgiSetArray("device_uri", i, device_uri); |
| i ++; |
| } |
| } |
| |
| if (!attr) |
| break; |
| } |
| |
| ippDelete(response); |
| |
| /* |
| * Free the device list... |
| */ |
| |
| for (printer_device = (char *)cupsArrayFirst(printer_devices); |
| printer_device; |
| printer_device = (char *)cupsArrayNext(printer_devices)) |
| free(printer_device); |
| |
| cupsArrayDelete(printer_devices); |
| } |
| } |
| |
| /* |
| * Finally, show the printer list... |
| */ |
| |
| cgiCopyTemplateLang("list-available-printers.tmpl"); |
| |
| cgiEndHTML(); |
| } |
| |
| |
| /* |
| * 'do_menu()' - Show the main menu. |
| */ |
| |
| static void |
| do_menu(http_t *http) /* I - HTTP connection */ |
| { |
| int num_settings; /* Number of server settings */ |
| cups_option_t *settings; /* Server settings */ |
| const char *val; /* Setting value */ |
| |
| |
| /* |
| * Get the current server settings... |
| */ |
| |
| if (!cupsAdminGetServerSettings(http, &num_settings, &settings)) |
| { |
| cgiSetVariable("SETTINGS_MESSAGE", |
| cgiText(_("Unable to open cupsd.conf file:"))); |
| cgiSetVariable("SETTINGS_ERROR", cupsLastErrorString()); |
| } |
| |
| if ((val = cupsGetOption(CUPS_SERVER_DEBUG_LOGGING, num_settings, |
| settings)) != NULL && atoi(val)) |
| cgiSetVariable("DEBUG_LOGGING", "CHECKED"); |
| |
| if ((val = cupsGetOption(CUPS_SERVER_REMOTE_ADMIN, num_settings, |
| settings)) != NULL && atoi(val)) |
| cgiSetVariable("REMOTE_ADMIN", "CHECKED"); |
| |
| if ((val = cupsGetOption(CUPS_SERVER_REMOTE_ANY, num_settings, |
| settings)) != NULL && atoi(val)) |
| cgiSetVariable("REMOTE_ANY", "CHECKED"); |
| |
| if ((val = cupsGetOption(CUPS_SERVER_SHARE_PRINTERS, num_settings, |
| settings)) != NULL && atoi(val)) |
| cgiSetVariable("SHARE_PRINTERS", "CHECKED"); |
| |
| if ((val = cupsGetOption(CUPS_SERVER_USER_CANCEL_ANY, num_settings, |
| settings)) != NULL && atoi(val)) |
| cgiSetVariable("USER_CANCEL_ANY", "CHECKED"); |
| |
| #ifdef HAVE_GSSAPI |
| cgiSetVariable("HAVE_GSSAPI", "1"); |
| |
| if ((val = cupsGetOption("DefaultAuthType", num_settings, |
| settings)) != NULL && !_cups_strcasecmp(val, "Negotiate")) |
| cgiSetVariable("KERBEROS", "CHECKED"); |
| else |
| #endif /* HAVE_GSSAPI */ |
| cgiSetVariable("KERBEROS", ""); |
| |
| if ((val = cupsGetOption("BrowseWebIF", num_settings, |
| settings)) == NULL) |
| val = "No"; |
| |
| if (!_cups_strcasecmp(val, "yes") || !_cups_strcasecmp(val, "on") || |
| !_cups_strcasecmp(val, "true")) |
| cgiSetVariable("BROWSE_WEB_IF", "CHECKED"); |
| |
| if ((val = cupsGetOption("PreserveJobHistory", num_settings, |
| settings)) == NULL) |
| val = "Yes"; |
| |
| if (val && |
| (!_cups_strcasecmp(val, "0") || !_cups_strcasecmp(val, "no") || |
| !_cups_strcasecmp(val, "off") || !_cups_strcasecmp(val, "false") || |
| !_cups_strcasecmp(val, "disabled"))) |
| { |
| cgiSetVariable("PRESERVE_JOB_HISTORY", "0"); |
| cgiSetVariable("PRESERVE_JOB_FILES", "0"); |
| } |
| else |
| { |
| cgiSetVariable("PRESERVE_JOBS", "CHECKED"); |
| cgiSetVariable("PRESERVE_JOB_HISTORY", val); |
| |
| if ((val = cupsGetOption("PreserveJobFiles", num_settings, |
| settings)) == NULL) |
| val = "1d"; |
| |
| cgiSetVariable("PRESERVE_JOB_FILES", val); |
| |
| } |
| |
| if ((val = cupsGetOption("MaxClients", num_settings, settings)) == NULL) |
| val = "100"; |
| |
| cgiSetVariable("MAX_CLIENTS", val); |
| |
| if ((val = cupsGetOption("MaxJobs", num_settings, settings)) == NULL) |
| val = "500"; |
| |
| cgiSetVariable("MAX_JOBS", val); |
| |
| if ((val = cupsGetOption("MaxLogSize", num_settings, settings)) == NULL) |
| val = "1m"; |
| |
| cgiSetVariable("MAX_LOG_SIZE", val); |
| |
| cupsFreeOptions(num_settings, settings); |
| |
| /* |
| * Finally, show the main menu template... |
| */ |
| |
| cgiStartHTML(cgiText(_("Administration"))); |
| |
| cgiCopyTemplateLang("admin.tmpl"); |
| |
| cgiEndHTML(); |
| } |
| |
| |
| /* |
| * 'do_set_allowed_users()' - Set the allowed/denied users for a queue. |
| */ |
| |
| static void |
| do_set_allowed_users(http_t *http) /* I - HTTP connection */ |
| { |
| int i; /* Looping var */ |
| ipp_t *request, /* IPP request */ |
| *response; /* IPP response */ |
| char uri[HTTP_MAX_URI]; /* Printer URI */ |
| const char *printer, /* Printer name (purge-jobs) */ |
| *is_class, /* Is a class? */ |
| *users, /* List of users or groups */ |
| *type; /* Allow/deny type */ |
| int num_users; /* Number of users */ |
| char *ptr, /* Pointer into users string */ |
| *end, /* Pointer to end of users string */ |
| quote; /* Quote character */ |
| ipp_attribute_t *attr; /* Attribute */ |
| static const char * const attrs[] = /* Requested attributes */ |
| { |
| "requesting-user-name-allowed", |
| "requesting-user-name-denied" |
| }; |
| |
| |
| is_class = cgiGetVariable("IS_CLASS"); |
| printer = cgiGetVariable("PRINTER_NAME"); |
| |
| if (!printer) |
| { |
| cgiSetVariable("ERROR", cgiText(_("Missing form variable"))); |
| cgiStartHTML(cgiText(_("Set Allowed Users"))); |
| cgiCopyTemplateLang("error.tmpl"); |
| cgiEndHTML(); |
| return; |
| } |
| |
| users = cgiGetVariable("users"); |
| type = cgiGetVariable("type"); |
| |
| if (!users || !type || |
| (strcmp(type, "requesting-user-name-allowed") && |
| strcmp(type, "requesting-user-name-denied"))) |
| { |
| /* |
| * Build a Get-Printer-Attributes request, which requires the following |
| * attributes: |
| * |
| * attributes-charset |
| * attributes-natural-language |
| * printer-uri |
| * requested-attributes |
| */ |
| |
| request = ippNewRequest(IPP_GET_PRINTER_ATTRIBUTES); |
| |
| httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL, |
| "localhost", 0, is_class ? "/classes/%s" : "/printers/%s", |
| printer); |
| ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", |
| NULL, uri); |
| |
| ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, |
| "requested-attributes", |
| (int)(sizeof(attrs) / sizeof(attrs[0])), NULL, attrs); |
| |
| /* |
| * Do the request and get back a response... |
| */ |
| |
| if ((response = cupsDoRequest(http, request, "/")) != NULL) |
| { |
| cgiSetIPPVars(response, NULL, NULL, NULL, 0); |
| |
| ippDelete(response); |
| } |
| |
| cgiStartHTML(cgiText(_("Set Allowed Users"))); |
| |
| if (cupsLastError() == IPP_NOT_AUTHORIZED) |
| { |
| puts("Status: 401\n"); |
| exit(0); |
| } |
| else if (cupsLastError() > IPP_OK_CONFLICT) |
| cgiShowIPPError(_("Unable to get printer attributes")); |
| else |
| cgiCopyTemplateLang("users.tmpl"); |
| |
| cgiEndHTML(); |
| } |
| else |
| { |
| /* |
| * Save the changes... |
| */ |
| |
| for (num_users = 0, ptr = (char *)users; *ptr; num_users ++) |
| { |
| /* |
| * Skip whitespace and commas... |
| */ |
| |
| while (*ptr == ',' || isspace(*ptr & 255)) |
| ptr ++; |
| |
| if (!*ptr) |
| break; |
| |
| if (*ptr == '\'' || *ptr == '\"') |
| { |
| /* |
| * Scan quoted name... |
| */ |
| |
| quote = *ptr++; |
| |
| for (end = ptr; *end; end ++) |
| if (*end == quote) |
| break; |
| } |
| else |
| { |
| /* |
| * Scan space or comma-delimited name... |
| */ |
| |
| for (end = ptr; *end; end ++) |
| if (isspace(*end & 255) || *end == ',') |
| break; |
| } |
| |
| /* |
| * Advance to the next name... |
| */ |
| |
| ptr = end; |
| } |
| |
| /* |
| * Build a CUPS-Add-Printer/Class request, which requires the following |
| * attributes: |
| * |
| * attributes-charset |
| * attributes-natural-language |
| * printer-uri |
| * requesting-user-name-{allowed,denied} |
| */ |
| |
| request = ippNewRequest(is_class ? CUPS_ADD_CLASS : CUPS_ADD_PRINTER); |
| |
| httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL, |
| "localhost", 0, is_class ? "/classes/%s" : "/printers/%s", |
| printer); |
| ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", |
| NULL, uri); |
| |
| if (num_users == 0) |
| ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_NAME, |
| "requesting-user-name-allowed", NULL, "all"); |
| else |
| { |
| attr = ippAddStrings(request, IPP_TAG_PRINTER, IPP_TAG_NAME, |
| type, num_users, NULL, NULL); |
| |
| for (i = 0, ptr = (char *)users; *ptr; i ++) |
| { |
| /* |
| * Skip whitespace and commas... |
| */ |
| |
| while (*ptr == ',' || isspace(*ptr & 255)) |
| ptr ++; |
| |
| if (!*ptr) |
| break; |
| |
| if (*ptr == '\'' || *ptr == '\"') |
| { |
| /* |
| * Scan quoted name... |
| */ |
| |
| quote = *ptr++; |
| |
| for (end = ptr; *end; end ++) |
| if (*end == quote) |
| break; |
| } |
| else |
| { |
| /* |
| * Scan space or comma-delimited name... |
| */ |
| |
| for (end = ptr; *end; end ++) |
| if (isspace(*end & 255) || *end == ',') |
| break; |
| } |
| |
| /* |
| * Terminate the name... |
| */ |
| |
| if (*end) |
| *end++ = '\0'; |
| |
| /* |
| * Add the name... |
| */ |
| |
| ippSetString(request, &attr, i, ptr); |
| |
| /* |
| * Advance to the next name... |
| */ |
| |
| ptr = end; |
| } |
| } |
| |
| /* |
| * Do the request and get back a response... |
| */ |
| |
| ippDelete(cupsDoRequest(http, request, "/admin/")); |
| |
| if (cupsLastError() == IPP_NOT_AUTHORIZED) |
| { |
| puts("Status: 401\n"); |
| exit(0); |
| } |
| else if (cupsLastError() > IPP_OK_CONFLICT) |
| { |
| cgiStartHTML(cgiText(_("Set Allowed Users"))); |
| cgiShowIPPError(_("Unable to change printer")); |
| } |
| else |
| { |
| /* |
| * Redirect successful updates back to the printer page... |
| */ |
| |
| char url[1024], /* Printer/class URL */ |
| refresh[1024]; /* Refresh URL */ |
| |
| |
| cgiRewriteURL(uri, url, sizeof(url), NULL); |
| cgiFormEncode(uri, url, sizeof(uri)); |
| snprintf(refresh, sizeof(refresh), "5;URL=/admin/?OP=redirect&URL=%s", |
| uri); |
| cgiSetVariable("refresh_page", refresh); |
| |
| cgiStartHTML(cgiText(_("Set Allowed Users"))); |
| |
| cgiCopyTemplateLang(is_class ? "class-modified.tmpl" : |
| "printer-modified.tmpl"); |
| } |
| |
| cgiEndHTML(); |
| } |
| } |
| |
| |
| /* |
| * 'do_set_default()' - Set the server default printer/class. |
| */ |
| |
| static void |
| do_set_default(http_t *http) /* I - HTTP connection */ |
| { |
| const char *title; /* Page title */ |
| ipp_t *request; /* IPP request */ |
| char uri[HTTP_MAX_URI]; /* Printer URI */ |
| const char *printer, /* Printer name (purge-jobs) */ |
| *is_class; /* Is a class? */ |
| |
| |
| is_class = cgiGetVariable("IS_CLASS"); |
| printer = cgiGetVariable("PRINTER_NAME"); |
| title = cgiText(_("Set As Server Default")); |
| |
| if (!printer) |
| { |
| cgiSetVariable("ERROR", cgiText(_("Missing form variable"))); |
| cgiStartHTML(title); |
| cgiCopyTemplateLang("error.tmpl"); |
| cgiEndHTML(); |
| return; |
| } |
| |
| /* |
| * Build a printer request, which requires the following |
| * attributes: |
| * |
| * attributes-charset |
| * attributes-natural-language |
| * printer-uri |
| */ |
| |
| request = ippNewRequest(CUPS_SET_DEFAULT); |
| |
| httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL, |
| "localhost", 0, is_class ? "/classes/%s" : "/printers/%s", |
| printer); |
| ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", |
| NULL, uri); |
| |
| /* |
| * Do the request and get back a response... |
| */ |
| |
| ippDelete(cupsDoRequest(http, request, "/admin/")); |
| |
| if (cupsLastError() == IPP_NOT_AUTHORIZED) |
| { |
| puts("Status: 401\n"); |
| exit(0); |
| } |
| else if (cupsLastError() > IPP_OK_CONFLICT) |
| { |
| cgiStartHTML(title); |
| cgiShowIPPError(_("Unable to set server default")); |
| } |
| else |
| { |
| /* |
| * Redirect successful updates back to the printer page... |
| */ |
| |
| char url[1024], /* Printer/class URL */ |
| refresh[1024]; /* Refresh URL */ |
| |
| |
| cgiRewriteURL(uri, url, sizeof(url), NULL); |
| cgiFormEncode(uri, url, sizeof(uri)); |
| snprintf(refresh, sizeof(refresh), "5;URL=/admin/?OP=redirect&URL=%s", uri); |
| cgiSetVariable("refresh_page", refresh); |
| |
| cgiStartHTML(title); |
| cgiCopyTemplateLang("printer-default.tmpl"); |
| } |
| |
| cgiEndHTML(); |
| } |
| |
| |
| /* |
| * 'do_set_options()' - Configure the default options for a queue. |
| */ |
| |
| static void |
| do_set_options(http_t *http, /* I - HTTP connection */ |
| int is_class) /* I - Set options for class? */ |
| { |
| int i, j, k, m; /* Looping vars */ |
| int have_options; /* Have options? */ |
| ipp_t *request, /* IPP request */ |
| *response; /* IPP response */ |
| ipp_attribute_t *attr; /* IPP attribute */ |
| char uri[HTTP_MAX_URI]; /* Job URI */ |
| const char *var; /* Variable value */ |
| const char *printer; /* Printer printer name */ |
| const char *filename; /* PPD filename */ |
| char tempfile[1024]; /* Temporary filename */ |
| cups_file_t *in, /* Input file */ |
| *out; /* Output file */ |
| char line[1024], /* Line from PPD file */ |
| value[1024], /* Option value */ |
| keyword[1024], /* Keyword from Default line */ |
| *keyptr; /* Pointer into keyword... */ |
| ppd_file_t *ppd; /* PPD file */ |
| ppd_group_t *group; /* Option group */ |
| ppd_option_t *option; /* Option */ |
| ppd_coption_t *coption; /* Custom option */ |
| ppd_cparam_t *cparam; /* Custom parameter */ |
| ppd_attr_t *ppdattr; /* PPD attribute */ |
| const char *title; /* Page title */ |
| |
| |
| title = cgiText(is_class ? _("Set Class Options") : _("Set Printer Options")); |
| |
| fprintf(stderr, "DEBUG: do_set_options(http=%p, is_class=%d)\n", http, |
| is_class); |
| |
| /* |
| * Get the printer name... |
| */ |
| |
| if ((printer = cgiGetVariable("PRINTER_NAME")) != NULL) |
| httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL, |
| "localhost", 0, is_class ? "/classes/%s" : "/printers/%s", |
| printer); |
| else |
| { |
| cgiSetVariable("ERROR", cgiText(_("Missing form variable"))); |
| cgiStartHTML(title); |
| cgiCopyTemplateLang("error.tmpl"); |
| cgiEndHTML(); |
| return; |
| } |
| |
| fprintf(stderr, "DEBUG: printer=\"%s\", uri=\"%s\"...\n", printer, uri); |
| |
| /* |
| * If the user clicks on the Auto-Configure button, send an AutoConfigure |
| * command file to the printer... |
| */ |
| |
| if (cgiGetVariable("AUTOCONFIGURE")) |
| { |
| cgiPrintCommand(http, printer, "AutoConfigure", "Set Default Options"); |
| return; |
| } |
| |
| /* |
| * Get the PPD file... |
| */ |
| |
| if (is_class) |
| filename = NULL; |
| else |
| filename = cupsGetPPD2(http, printer); |
| |
| if (filename) |
| { |
| fprintf(stderr, "DEBUG: Got PPD file: \"%s\"\n", filename); |
| |
| if ((ppd = ppdOpenFile(filename)) == NULL) |
| { |
| cgiSetVariable("ERROR", ppdErrorString(ppdLastError(&i))); |
| cgiSetVariable("MESSAGE", cgiText(_("Unable to open PPD file"))); |
| cgiStartHTML(title); |
| cgiCopyTemplateLang("error.tmpl"); |
| cgiEndHTML(); |
| return; |
| } |
| } |
| else |
| { |
| fputs("DEBUG: No PPD file\n", stderr); |
| ppd = NULL; |
| } |
| |
| if (cgiGetVariable("job_sheets_start") != NULL || |
| cgiGetVariable("job_sheets_end") != NULL) |
| have_options = 1; |
| else |
| have_options = 0; |
| |
| if (ppd) |
| { |
| ppdMarkDefaults(ppd); |
| |
| for (option = ppdFirstOption(ppd); |
| option; |
| option = ppdNextOption(ppd)) |
| { |
| if ((var = cgiGetVariable(option->keyword)) != NULL) |
| { |
| have_options = 1; |
| ppdMarkOption(ppd, option->keyword, var); |
| fprintf(stderr, "DEBUG: Set %s to %s...\n", option->keyword, var); |
| } |
| else |
| fprintf(stderr, "DEBUG: Didn't find %s...\n", option->keyword); |
| } |
| } |
| |
| if (!have_options || ppdConflicts(ppd)) |
| { |
| /* |
| * Show the options to the user... |
| */ |
| |
| fputs("DEBUG: Showing options...\n", stderr); |
| |
| /* |
| * Show auto-configure button if supported... |
| */ |
| |
| if (ppd) |
| { |
| if (ppd->num_filters == 0 || |
| ((ppdattr = ppdFindAttr(ppd, "cupsCommands", NULL)) != NULL && |
| ppdattr->value && strstr(ppdattr->value, "AutoConfigure"))) |
| cgiSetVariable("HAVE_AUTOCONFIGURE", "YES"); |
| else |
| { |
| for (i = 0; i < ppd->num_filters; i ++) |
| if (!strncmp(ppd->filters[i], "application/vnd.cups-postscript", 31)) |
| { |
| cgiSetVariable("HAVE_AUTOCONFIGURE", "YES"); |
| break; |
| } |
| } |
| } |
| |
| /* |
| * Get the printer attributes... |
| */ |
| |
| request = ippNewRequest(IPP_GET_PRINTER_ATTRIBUTES); |
| |
| httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL, |
| "localhost", 0, "/printers/%s", printer); |
| ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", |
| NULL, uri); |
| |
| response = cupsDoRequest(http, request, "/"); |
| |
| /* |
| * List the groups used as "tabs"... |
| */ |
| |
| i = 0; |
| |
| if (ppd) |
| { |
| for (group = ppd->groups; |
| i < ppd->num_groups; |
| i ++, group ++) |
| { |
| cgiSetArray("GROUP_ID", i, group->name); |
| |
| if (!strcmp(group->name, "InstallableOptions")) |
| cgiSetArray("GROUP", i, cgiText(_("Options Installed"))); |
| else |
| cgiSetArray("GROUP", i, group->text); |
| } |
| } |
| |
| if (ippFindAttribute(response, "job-sheets-supported", IPP_TAG_ZERO)) |
| { |
| cgiSetArray("GROUP_ID", i, "CUPS_BANNERS"); |
| cgiSetArray("GROUP", i ++, cgiText(_("Banners"))); |
| } |
| |
| if (ippFindAttribute(response, "printer-error-policy-supported", |
| IPP_TAG_ZERO) || |
| ippFindAttribute(response, "printer-op-policy-supported", |
| IPP_TAG_ZERO)) |
| { |
| cgiSetArray("GROUP_ID", i, "CUPS_POLICIES"); |
| cgiSetArray("GROUP", i ++, cgiText(_("Policies"))); |
| } |
| |
| if ((attr = ippFindAttribute(response, "port-monitor-supported", |
| IPP_TAG_NAME)) != NULL && attr->num_values > 1) |
| { |
| cgiSetArray("GROUP_ID", i, "CUPS_PORT_MONITOR"); |
| cgiSetArray("GROUP", i, cgiText(_("Port Monitor"))); |
| } |
| |
| cgiStartHTML(cgiText(_("Set Printer Options"))); |
| cgiCopyTemplateLang("set-printer-options-header.tmpl"); |
| |
| if (ppd) |
| { |
| ppdLocalize(ppd); |
| |
| if (ppdConflicts(ppd)) |
| { |
| for (i = ppd->num_groups, k = 0, group = ppd->groups; |
| i > 0; |
| i --, group ++) |
| for (j = group->num_options, option = group->options; |
| j > 0; |
| j --, option ++) |
| if (option->conflicted) |
| { |
| cgiSetArray("ckeyword", k, option->keyword); |
| cgiSetArray("ckeytext", k, option->text); |
| |
| for (m = 0; m < option->num_choices; m ++) |
| { |
| if (option->choices[m].marked) |
| { |
| cgiSetArray("cchoice", k, option->choices[m].text); |
| break; |
| } |
| } |
| |
| k ++; |
| } |
| |
| cgiCopyTemplateLang("option-conflict.tmpl"); |
| } |
| |
| for (i = ppd->num_groups, group = ppd->groups; |
| i > 0; |
| i --, group ++) |
| { |
| for (j = group->num_options, option = group->options; |
| j > 0; |
| j --, option ++) |
| { |
| if (!strcmp(option->keyword, "PageRegion")) |
| continue; |
| |
| if (option->num_choices > 1) |
| break; |
| } |
| |
| if (j == 0) |
| continue; |
| |
| cgiSetVariable("GROUP_ID", group->name); |
| |
| if (!strcmp(group->name, "InstallableOptions")) |
| cgiSetVariable("GROUP", cgiText(_("Options Installed"))); |
| else |
| cgiSetVariable("GROUP", group->text); |
| |
| cgiCopyTemplateLang("option-header.tmpl"); |
| |
| for (j = group->num_options, option = group->options; |
| j > 0; |
| j --, option ++) |
| { |
| if (!strcmp(option->keyword, "PageRegion") || option->num_choices < 2) |
| continue; |
| |
| cgiSetVariable("KEYWORD", option->keyword); |
| cgiSetVariable("KEYTEXT", option->text); |
| |
| if (option->conflicted) |
| cgiSetVariable("CONFLICTED", "1"); |
| else |
| cgiSetVariable("CONFLICTED", "0"); |
| |
| cgiSetSize("CHOICES", 0); |
| cgiSetSize("TEXT", 0); |
| for (k = 0, m = 0; k < option->num_choices; k ++) |
| { |
| cgiSetArray("CHOICES", m, option->choices[k].choice); |
| cgiSetArray("TEXT", m, option->choices[k].text); |
| |
| m ++; |
| |
| if (option->choices[k].marked) |
| cgiSetVariable("DEFCHOICE", option->choices[k].choice); |
| } |
| |
| cgiSetSize("PARAMS", 0); |
| cgiSetSize("PARAMTEXT", 0); |
| cgiSetSize("PARAMVALUE", 0); |
| cgiSetSize("INPUTTYPE", 0); |
| |
| if ((coption = ppdFindCustomOption(ppd, option->keyword))) |
| { |
| const char *units = NULL; /* Units value, if any */ |
| |
| cgiSetVariable("ISCUSTOM", "1"); |
| |
| for (cparam = ppdFirstCustomParam(coption), m = 0; |
| cparam; |
| cparam = ppdNextCustomParam(coption), m ++) |
| { |
| if (!_cups_strcasecmp(option->keyword, "PageSize") && |
| _cups_strcasecmp(cparam->name, "Width") && |
| _cups_strcasecmp(cparam->name, "Height")) |
| { |
| m --; |
| continue; |
| } |
| |
| cgiSetArray("PARAMS", m, cparam->name); |
| cgiSetArray("PARAMTEXT", m, cparam->text); |
| cgiSetArray("INPUTTYPE", m, "text"); |
| |
| switch (cparam->type) |
| { |
| case PPD_CUSTOM_UNKNOWN : |
| break; |
| |
| case PPD_CUSTOM_POINTS : |
| if (!_cups_strncasecmp(option->defchoice, "Custom.", 7)) |
| { |
| units = option->defchoice + strlen(option->defchoice) - 2; |
| |
| if (strcmp(units, "mm") && strcmp(units, "cm") && |
| strcmp(units, "in") && strcmp(units, "ft")) |
| { |
| if (units[1] == 'm') |
| units ++; |
| else |
| units = "pt"; |
| } |
| } |
| else |
| units = "pt"; |
| |
| if (!strcmp(units, "mm")) |
| snprintf(value, sizeof(value), "%g", |
| cparam->current.custom_points / 72.0 * 25.4); |
| else if (!strcmp(units, "cm")) |
| snprintf(value, sizeof(value), "%g", |
| cparam->current.custom_points / 72.0 * 2.54); |
| else if (!strcmp(units, "in")) |
| snprintf(value, sizeof(value), "%g", |
| cparam->current.custom_points / 72.0); |
| else if (!strcmp(units, "ft")) |
| snprintf(value, sizeof(value), "%g", |
| cparam->current.custom_points / 72.0 / 12.0); |
| else if (!strcmp(units, "m")) |
| snprintf(value, sizeof(value), "%g", |
| cparam->current.custom_points / 72.0 * 0.0254); |
| else |
| snprintf(value, sizeof(value), "%g", |
| cparam->current.custom_points); |
| cgiSetArray("PARAMVALUE", m, value); |
| break; |
| |
| case PPD_CUSTOM_CURVE : |
| case PPD_CUSTOM_INVCURVE : |
| case PPD_CUSTOM_REAL : |
| snprintf(value, sizeof(value), "%g", |
| cparam->current.custom_real); |
| cgiSetArray("PARAMVALUE", m, value); |
| break; |
| |
| case PPD_CUSTOM_INT: |
| snprintf(value, sizeof(value), "%d", |
| cparam->current.custom_int); |
| cgiSetArray("PARAMVALUE", m, value); |
| break; |
| |
| case PPD_CUSTOM_PASSCODE: |
| case PPD_CUSTOM_PASSWORD: |
| if (cparam->current.custom_password) |
| cgiSetArray("PARAMVALUE", m, |
| cparam->current.custom_password); |
| else |
| cgiSetArray("PARAMVALUE", m, ""); |
| cgiSetArray("INPUTTYPE", m, "password"); |
| break; |
| |
| case PPD_CUSTOM_STRING: |
| if (cparam->current.custom_string) |
| cgiSetArray("PARAMVALUE", m, |
| cparam->current.custom_string); |
| else |
| cgiSetArray("PARAMVALUE", m, ""); |
| break; |
| } |
| } |
| |
| if (units) |
| { |
| cgiSetArray("PARAMS", m, "Units"); |
| cgiSetArray("PARAMTEXT", m, cgiText(_("Units"))); |
| cgiSetArray("PARAMVALUE", m, units); |
| } |
| } |
| else |
| cgiSetVariable("ISCUSTOM", "0"); |
| |
| switch (option->ui) |
| { |
| case PPD_UI_BOOLEAN : |
| cgiCopyTemplateLang("option-boolean.tmpl"); |
| break; |
| case PPD_UI_PICKONE : |
| cgiCopyTemplateLang("option-pickone.tmpl"); |
| break; |
| case PPD_UI_PICKMANY : |
| cgiCopyTemplateLang("option-pickmany.tmpl"); |
| break; |
| } |
| } |
| |
| cgiCopyTemplateLang("option-trailer.tmpl"); |
| } |
| } |
| |
| if ((attr = ippFindAttribute(response, "job-sheets-supported", |
| IPP_TAG_ZERO)) != NULL) |
| { |
| /* |
| * Add the job sheets options... |
| */ |
| |
| cgiSetVariable("GROUP_ID", "CUPS_BANNERS"); |
| cgiSetVariable("GROUP", cgiText(_("Banners"))); |
| cgiCopyTemplateLang("option-header.tmpl"); |
| |
| cgiSetSize("CHOICES", attr->num_values); |
| cgiSetSize("TEXT", attr->num_values); |
| for (k = 0; k < attr->num_values; k ++) |
| { |
| cgiSetArray("CHOICES", k, attr->values[k].string.text); |
| cgiSetArray("TEXT", k, attr->values[k].string.text); |
| } |
| |
| attr = ippFindAttribute(response, "job-sheets-default", IPP_TAG_ZERO); |
| |
| cgiSetVariable("KEYWORD", "job_sheets_start"); |
| cgiSetVariable("KEYTEXT", |
| /* TRANSLATORS: Banner/cover sheet before the print job. */ |
| cgiText(_("Starting Banner"))); |
| cgiSetVariable("DEFCHOICE", attr != NULL ? |
| attr->values[0].string.text : ""); |
| |
| cgiCopyTemplateLang("option-pickone.tmpl"); |
| |
| cgiSetVariable("KEYWORD", "job_sheets_end"); |
| cgiSetVariable("KEYTEXT", |
| /* TRANSLATORS: Banner/cover sheet after the print job. */ |
| cgiText(_("Ending Banner"))); |
| cgiSetVariable("DEFCHOICE", attr != NULL && attr->num_values > 1 ? |
| attr->values[1].string.text : ""); |
| |
| cgiCopyTemplateLang("option-pickone.tmpl"); |
| |
| cgiCopyTemplateLang("option-trailer.tmpl"); |
| } |
| |
| if (ippFindAttribute(response, "printer-error-policy-supported", |
| IPP_TAG_ZERO) || |
| ippFindAttribute(response, "printer-op-policy-supported", |
| IPP_TAG_ZERO)) |
| { |
| /* |
| * Add the error and operation policy options... |
| */ |
| |
| cgiSetVariable("GROUP_ID", "CUPS_POLICIES"); |
| cgiSetVariable("GROUP", cgiText(_("Policies"))); |
| cgiCopyTemplateLang("option-header.tmpl"); |
| |
| /* |
| * Error policy... |
| */ |
| |
| attr = ippFindAttribute(response, "printer-error-policy-supported", |
| IPP_TAG_ZERO); |
| |
| if (attr) |
| { |
| cgiSetSize("CHOICES", attr->num_values); |
| cgiSetSize("TEXT", attr->num_values); |
| for (k = 0; k < attr->num_values; k ++) |
| { |
| cgiSetArray("CHOICES", k, attr->values[k].string.text); |
| cgiSetArray("TEXT", k, attr->values[k].string.text); |
| } |
| |
| attr = ippFindAttribute(response, "printer-error-policy", |
| IPP_TAG_ZERO); |
| |
| cgiSetVariable("KEYWORD", "printer_error_policy"); |
| cgiSetVariable("KEYTEXT", cgiText(_("Error Policy"))); |
| cgiSetVariable("DEFCHOICE", attr == NULL ? |
| "" : attr->values[0].string.text); |
| } |
| |
| cgiCopyTemplateLang("option-pickone.tmpl"); |
| |
| /* |
| * Operation policy... |
| */ |
| |
| attr = ippFindAttribute(response, "printer-op-policy-supported", |
| IPP_TAG_ZERO); |
| |
| if (attr) |
| { |
| cgiSetSize("CHOICES", attr->num_values); |
| cgiSetSize("TEXT", attr->num_values); |
| for (k = 0; k < attr->num_values; k ++) |
| { |
| cgiSetArray("CHOICES", k, attr->values[k].string.text); |
| cgiSetArray("TEXT", k, attr->values[k].string.text); |
| } |
| |
| attr = ippFindAttribute(response, "printer-op-policy", IPP_TAG_ZERO); |
| |
| cgiSetVariable("KEYWORD", "printer_op_policy"); |
| cgiSetVariable("KEYTEXT", cgiText(_("Operation Policy"))); |
| cgiSetVariable("DEFCHOICE", attr == NULL ? |
| "" : attr->values[0].string.text); |
| |
| cgiCopyTemplateLang("option-pickone.tmpl"); |
| } |
| |
| cgiCopyTemplateLang("option-trailer.tmpl"); |
| } |
| |
| /* |
| * Binary protocol support... |
| */ |
| |
| if ((attr = ippFindAttribute(response, "port-monitor-supported", |
| IPP_TAG_NAME)) != NULL && attr->num_values > 1) |
| { |
| cgiSetVariable("GROUP_ID", "CUPS_PORT_MONITOR"); |
| cgiSetVariable("GROUP", cgiText(_("Port Monitor"))); |
| |
| cgiSetSize("CHOICES", attr->num_values); |
| cgiSetSize("TEXT", attr->num_values); |
| |
| for (i = 0; i < attr->num_values; i ++) |
| { |
| cgiSetArray("CHOICES", i, attr->values[i].string.text); |
| cgiSetArray("TEXT", i, attr->values[i].string.text); |
| } |
| |
| attr = ippFindAttribute(response, "port-monitor", IPP_TAG_NAME); |
| cgiSetVariable("KEYWORD", "port_monitor"); |
| cgiSetVariable("KEYTEXT", cgiText(_("Port Monitor"))); |
| cgiSetVariable("DEFCHOICE", attr ? attr->values[0].string.text : "none"); |
| |
| cgiCopyTemplateLang("option-header.tmpl"); |
| cgiCopyTemplateLang("option-pickone.tmpl"); |
| cgiCopyTemplateLang("option-trailer.tmpl"); |
| } |
| |
| cgiCopyTemplateLang("set-printer-options-trailer.tmpl"); |
| cgiEndHTML(); |
| |
| ippDelete(response); |
| } |
| else |
| { |
| /* |
| * Set default options... |
| */ |
| |
| fputs("DEBUG: Setting options...\n", stderr); |
| |
| if (filename) |
| { |
| out = cupsTempFile2(tempfile, sizeof(tempfile)); |
| in = cupsFileOpen(filename, "r"); |
| |
| if (!in || !out) |
| { |
| cgiSetVariable("ERROR", strerror(errno)); |
| cgiStartHTML(cgiText(_("Set Printer Options"))); |
| cgiCopyTemplateLang("error.tmpl"); |
| cgiEndHTML(); |
| |
| if (in) |
| cupsFileClose(in); |
| |
| if (out) |
| { |
| cupsFileClose(out); |
| unlink(tempfile); |
| } |
| |
| unlink(filename); |
| return; |
| } |
| |
| while (cupsFileGets(in, line, sizeof(line))) |
| { |
| if (!strncmp(line, "*cupsProtocol:", 14)) |
| continue; |
| else if (strncmp(line, "*Default", 8)) |
| cupsFilePrintf(out, "%s\n", line); |
| else |
| { |
| /* |
| * Get default option name... |
| */ |
| |
| strlcpy(keyword, line + 8, sizeof(keyword)); |
| |
| for (keyptr = keyword; *keyptr; keyptr ++) |
| if (*keyptr == ':' || isspace(*keyptr & 255)) |
| break; |
| |
| *keyptr = '\0'; |
| |
| if (!strcmp(keyword, "PageRegion") || |
| !strcmp(keyword, "PaperDimension") || |
| !strcmp(keyword, "ImageableArea")) |
| var = get_option_value(ppd, "PageSize", value, sizeof(value)); |
| else |
| var = get_option_value(ppd, keyword, value, sizeof(value)); |
| |
| if (!var) |
| cupsFilePrintf(out, "%s\n", line); |
| else |
| cupsFilePrintf(out, "*Default%s: %s\n", keyword, var); |
| } |
| } |
| |
| cupsFileClose(in); |
| cupsFileClose(out); |
| } |
| else |
| { |
| /* |
| * Make sure temporary filename is cleared when there is no PPD... |
| */ |
| |
| tempfile[0] = '\0'; |
| } |
| |
| /* |
| * Build a CUPS_ADD_MODIFY_CLASS/PRINTER request, which requires the |
| * following attributes: |
| * |
| * attributes-charset |
| * attributes-natural-language |
| * printer-uri |
| * job-sheets-default |
| * printer-error-policy |
| * printer-op-policy |
| * [ppd file] |
| */ |
| |
| request = ippNewRequest(is_class ? CUPS_ADD_MODIFY_CLASS : |
| CUPS_ADD_MODIFY_PRINTER); |
| |
| ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", |
| NULL, uri); |
| |
| attr = ippAddStrings(request, IPP_TAG_PRINTER, IPP_TAG_NAME, |
| "job-sheets-default", 2, NULL, NULL); |
| ippSetString(request, &attr, 0, cgiGetVariable("job_sheets_start")); |
| ippSetString(request, &attr, 1, cgiGetVariable("job_sheets_end")); |
| |
| if ((var = cgiGetVariable("printer_error_policy")) != NULL) |
| ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_NAME, |
| "printer-error-policy", NULL, var); |
| |
| if ((var = cgiGetVariable("printer_op_policy")) != NULL) |
| ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_NAME, |
| "printer-op-policy", NULL, var); |
| |
| if ((var = cgiGetVariable("port_monitor")) != NULL) |
| ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_NAME, |
| "port-monitor", NULL, var); |
| |
| /* |
| * Do the request and get back a response... |
| */ |
| |
| if (filename) |
| ippDelete(cupsDoFileRequest(http, request, "/admin/", tempfile)); |
| else |
| ippDelete(cupsDoRequest(http, request, "/admin/")); |
| |
| if (cupsLastError() == IPP_NOT_AUTHORIZED) |
| { |
| puts("Status: 401\n"); |
| exit(0); |
| } |
| else if (cupsLastError() > IPP_OK_CONFLICT) |
| { |
| cgiStartHTML(title); |
| cgiShowIPPError(_("Unable to set options")); |
| } |
| else |
| { |
| /* |
| * Redirect successful updates back to the printer page... |
| */ |
| |
| char refresh[1024]; /* Refresh URL */ |
| |
| |
| cgiFormEncode(uri, printer, sizeof(uri)); |
| snprintf(refresh, sizeof(refresh), "5;URL=/admin/?OP=redirect&URL=/%s/%s", |
| is_class ? "classes" : "printers", uri); |
| cgiSetVariable("refresh_page", refresh); |
| |
| cgiStartHTML(title); |
| |
| cgiCopyTemplateLang("printer-configured.tmpl"); |
| } |
| |
| cgiEndHTML(); |
| |
| if (filename) |
| unlink(tempfile); |
| } |
| |
| if (filename) |
| unlink(filename); |
| } |
| |
| |
| /* |
| * 'do_set_sharing()' - Set printer-is-shared value. |
| */ |
| |
| static void |
| do_set_sharing(http_t *http) /* I - HTTP connection */ |
| { |
| ipp_t *request, /* IPP request */ |
| *response; /* IPP response */ |
| char uri[HTTP_MAX_URI]; /* Printer URI */ |
| const char *printer, /* Printer name */ |
| *is_class, /* Is a class? */ |
| *shared; /* Sharing value */ |
| |
| |
| is_class = cgiGetVariable("IS_CLASS"); |
| printer = cgiGetVariable("PRINTER_NAME"); |
| shared = cgiGetVariable("SHARED"); |
| |
| if (!printer || !shared) |
| { |
| cgiSetVariable("ERROR", cgiText(_("Missing form variable"))); |
| cgiStartHTML(cgiText(_("Set Publishing"))); |
| cgiCopyTemplateLang("error.tmpl"); |
| cgiEndHTML(); |
| return; |
| } |
| |
| /* |
| * Build a CUPS-Add-Printer/CUPS-Add-Class request, which requires the |
| * following attributes: |
| * |
| * attributes-charset |
| * attributes-natural-language |
| * printer-uri |
| * printer-is-shared |
| */ |
| |
| request = ippNewRequest(is_class ? CUPS_ADD_CLASS : CUPS_ADD_PRINTER); |
| |
| httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL, |
| "localhost", 0, is_class ? "/classes/%s" : "/printers/%s", |
| printer); |
| ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", |
| NULL, uri); |
| |
| ippAddBoolean(request, IPP_TAG_OPERATION, "printer-is-shared", (char)atoi(shared)); |
| |
| /* |
| * Do the request and get back a response... |
| */ |
| |
| if ((response = cupsDoRequest(http, request, "/admin/")) != NULL) |
| { |
| cgiSetIPPVars(response, NULL, NULL, NULL, 0); |
| |
| ippDelete(response); |
| } |
| |
| if (cupsLastError() == IPP_NOT_AUTHORIZED) |
| { |
| puts("Status: 401\n"); |
| exit(0); |
| } |
| else if (cupsLastError() > IPP_OK_CONFLICT) |
| { |
| cgiStartHTML(cgiText(_("Set Publishing"))); |
| cgiShowIPPError(_("Unable to change printer-is-shared attribute")); |
| } |
| else |
| { |
| /* |
| * Redirect successful updates back to the printer page... |
| */ |
| |
| char url[1024], /* Printer/class URL */ |
| refresh[1024]; /* Refresh URL */ |
| |
| |
| cgiRewriteURL(uri, url, sizeof(url), NULL); |
| cgiFormEncode(uri, url, sizeof(uri)); |
| snprintf(refresh, sizeof(refresh), "5;URL=/admin/?OP=redirect&URL=%s", uri); |
| cgiSetVariable("refresh_page", refresh); |
| |
| cgiStartHTML(cgiText(_("Set Publishing"))); |
| cgiCopyTemplateLang(is_class ? "class-modified.tmpl" : |
| "printer-modified.tmpl"); |
| } |
| |
| cgiEndHTML(); |
| } |
| |
| |
| /* |
| * 'get_option_value()' - Return the value of an option. |
| * |
| * This function also handles generation of custom option values. |
| */ |
| |
| static char * /* O - Value string or NULL on error */ |
| get_option_value( |
| ppd_file_t *ppd, /* I - PPD file */ |
| const char *name, /* I - Option name */ |
| char *buffer, /* I - String buffer */ |
| size_t bufsize) /* I - Size of buffer */ |
| { |
| char *bufptr, /* Pointer into buffer */ |
| *bufend; /* End of buffer */ |
| ppd_coption_t *coption; /* Custom option */ |
| ppd_cparam_t *cparam; /* Current custom parameter */ |
| char keyword[256]; /* Parameter name */ |
| const char *val, /* Parameter value */ |
| *uval; /* Units value */ |
| long integer; /* Integer value */ |
| double number, /* Number value */ |
| number_points; /* Number in points */ |
| |
| |
| /* |
| * See if we have a custom option choice... |
| */ |
| |
| if ((val = cgiGetVariable(name)) == NULL) |
| { |
| /* |
| * Option not found! |
| */ |
| |
| return (NULL); |
| } |
| else if (_cups_strcasecmp(val, "Custom") || |
| (coption = ppdFindCustomOption(ppd, name)) == NULL) |
| { |
| /* |
| * Not a custom choice... |
| */ |
| |
| strlcpy(buffer, val, bufsize); |
| return (buffer); |
| } |
| |
| /* |
| * OK, we have a custom option choice, format it... |
| */ |
| |
| *buffer = '\0'; |
| |
| if (!strcmp(coption->keyword, "PageSize")) |
| { |
| const char *lval; /* Length string value */ |
| double width, /* Width value */ |
| width_points, /* Width in points */ |
| length, /* Length value */ |
| length_points; /* Length in points */ |
| |
| |
| val = cgiGetVariable("PageSize.Width"); |
| lval = cgiGetVariable("PageSize.Height"); |
| uval = cgiGetVariable("PageSize.Units"); |
| |
| if (!val || !lval || !uval || |
| (width = strtod(val, NULL)) == 0.0 || |
| (length = strtod(lval, NULL)) == 0.0 || |
| (strcmp(uval, "pt") && strcmp(uval, "in") && strcmp(uval, "ft") && |
| strcmp(uval, "cm") && strcmp(uval, "mm") && strcmp(uval, "m"))) |
| return (NULL); |
| |
| width_points = get_points(width, uval); |
| length_points = get_points(length, uval); |
| |
| if (width_points < ppd->custom_min[0] || |
| width_points > ppd->custom_max[0] || |
| length_points < ppd->custom_min[1] || |
| length_points > ppd->custom_max[1]) |
| return (NULL); |
| |
| snprintf(buffer, bufsize, "Custom.%gx%g%s", width, length, uval); |
| } |
| else if (cupsArrayCount(coption->params) == 1) |
| { |
| cparam = ppdFirstCustomParam(coption); |
| snprintf(keyword, sizeof(keyword), "%s.%s", coption->keyword, cparam->name); |
| |
| if ((val = cgiGetVariable(keyword)) == NULL) |
| return (NULL); |
| |
| switch (cparam->type) |
| { |
| case PPD_CUSTOM_UNKNOWN : |
| break; |
| |
| case PPD_CUSTOM_CURVE : |
| case PPD_CUSTOM_INVCURVE : |
| case PPD_CUSTOM_REAL : |
| if ((number = strtod(val, NULL)) == 0.0 || |
| number < cparam->minimum.custom_real || |
| number > cparam->maximum.custom_real) |
| return (NULL); |
| |
| snprintf(buffer, bufsize, "Custom.%g", number); |
| break; |
| |
| case PPD_CUSTOM_INT : |
| if (!*val || (integer = strtol(val, NULL, 10)) == LONG_MIN || |
| integer == LONG_MAX || |
| integer < cparam->minimum.custom_int || |
| integer > cparam->maximum.custom_int) |
| return (NULL); |
| |
| snprintf(buffer, bufsize, "Custom.%ld", integer); |
| break; |
| |
| case PPD_CUSTOM_POINTS : |
| snprintf(keyword, sizeof(keyword), "%s.Units", coption->keyword); |
| |
| if ((number = strtod(val, NULL)) == 0.0 || |
| (uval = cgiGetVariable(keyword)) == NULL || |
| (strcmp(uval, "pt") && strcmp(uval, "in") && strcmp(uval, "ft") && |
| strcmp(uval, "cm") && strcmp(uval, "mm") && strcmp(uval, "m"))) |
| return (NULL); |
| |
| number_points = get_points(number, uval); |
| if (number_points < cparam->minimum.custom_points || |
| number_points > cparam->maximum.custom_points) |
| return (NULL); |
| |
| snprintf(buffer, bufsize, "Custom.%g%s", number, uval); |
| break; |
| |
| case PPD_CUSTOM_PASSCODE : |
| for (uval = val; *uval; uval ++) |
| if (!isdigit(*uval & 255)) |
| return (NULL); |
| |
| case PPD_CUSTOM_PASSWORD : |
| case PPD_CUSTOM_STRING : |
| integer = (long)strlen(val); |
| if (integer < cparam->minimum.custom_string || |
| integer > cparam->maximum.custom_string) |
| return (NULL); |
| |
| snprintf(buffer, bufsize, "Custom.%s", val); |
| break; |
| } |
| } |
| else |
| { |
| const char *prefix = "{"; /* Prefix string */ |
| |
| |
| bufptr = buffer; |
| bufend = buffer + bufsize; |
| |
| for (cparam = ppdFirstCustomParam(coption); |
| cparam; |
| cparam = ppdNextCustomParam(coption)) |
| { |
| snprintf(keyword, sizeof(keyword), "%s.%s", coption->keyword, |
| cparam->name); |
| |
| if ((val = cgiGetVariable(keyword)) == NULL) |
| return (NULL); |
| |
| snprintf(bufptr, (size_t)(bufend - bufptr), "%s%s=", prefix, cparam->name); |
| bufptr += strlen(bufptr); |
| prefix = " "; |
| |
| switch (cparam->type) |
| { |
| case PPD_CUSTOM_UNKNOWN : |
| break; |
| |
| case PPD_CUSTOM_CURVE : |
| case PPD_CUSTOM_INVCURVE : |
| case PPD_CUSTOM_REAL : |
| if ((number = strtod(val, NULL)) == 0.0 || |
| number < cparam->minimum.custom_real || |
| number > cparam->maximum.custom_real) |
| return (NULL); |
| |
| snprintf(bufptr, (size_t)(bufend - bufptr), "%g", number); |
| break; |
| |
| case PPD_CUSTOM_INT : |
| if (!*val || (integer = strtol(val, NULL, 10)) == LONG_MIN || |
| integer == LONG_MAX || |
| integer < cparam->minimum.custom_int || |
| integer > cparam->maximum.custom_int) |
| return (NULL); |
| |
| snprintf(bufptr, (size_t)(bufend - bufptr), "%ld", integer); |
| break; |
| |
| case PPD_CUSTOM_POINTS : |
| snprintf(keyword, sizeof(keyword), "%s.Units", coption->keyword); |
| |
| if ((number = strtod(val, NULL)) == 0.0 || |
| (uval = cgiGetVariable(keyword)) == NULL || |
| (strcmp(uval, "pt") && strcmp(uval, "in") && |
| strcmp(uval, "ft") && strcmp(uval, "cm") && |
| strcmp(uval, "mm") && strcmp(uval, "m"))) |
| return (NULL); |
| |
| number_points = get_points(number, uval); |
| if (number_points < cparam->minimum.custom_points || |
| number_points > cparam->maximum.custom_points) |
| return (NULL); |
| |
| snprintf(bufptr, (size_t)(bufend - bufptr), "%g%s", number, uval); |
| break; |
| |
| case PPD_CUSTOM_PASSCODE : |
| for (uval = val; *uval; uval ++) |
| if (!isdigit(*uval & 255)) |
| return (NULL); |
| |
| case PPD_CUSTOM_PASSWORD : |
| case PPD_CUSTOM_STRING : |
| integer = (long)strlen(val); |
| if (integer < cparam->minimum.custom_string || |
| integer > cparam->maximum.custom_string) |
| return (NULL); |
| |
| if ((bufptr + 2) > bufend) |
| return (NULL); |
| |
| bufend --; |
| *bufptr++ = '\"'; |
| |
| while (*val && bufptr < bufend) |
| { |
| if (*val == '\\' || *val == '\"') |
| { |
| if ((bufptr + 1) >= bufend) |
| return (NULL); |
| |
| *bufptr++ = '\\'; |
| } |
| |
| *bufptr++ = *val++; |
| } |
| |
| if (bufptr >= bufend) |
| return (NULL); |
| |
| *bufptr++ = '\"'; |
| *bufptr = '\0'; |
| bufend ++; |
| break; |
| } |
| |
| bufptr += strlen(bufptr); |
| } |
| |
| if (bufptr == buffer || (bufend - bufptr) < 2) |
| return (NULL); |
| |
| memcpy(bufptr, "}", 2); |
| } |
| |
| return (buffer); |
| } |
| |
| |
| /* |
| * 'get_points()' - Get a value in points. |
| */ |
| |
| static double /* O - Number in points */ |
| get_points(double number, /* I - Original number */ |
| const char *uval) /* I - Units */ |
| { |
| if (!strcmp(uval, "mm")) /* Millimeters */ |
| return (number * 72.0 / 25.4); |
| else if (!strcmp(uval, "cm")) /* Centimeters */ |
| return (number * 72.0 / 2.54); |
| else if (!strcmp(uval, "in")) /* Inches */ |
| return (number * 72.0); |
| else if (!strcmp(uval, "ft")) /* Feet */ |
| return (number * 72.0 * 12.0); |
| else if (!strcmp(uval, "m")) /* Meters */ |
| return (number * 72.0 / 0.0254); |
| else /* Points */ |
| return (number); |
| } |
| |
| |
| /* |
| * 'get_printer_ppd()' - Get an IPP Everywhere PPD file for the given URI. |
| */ |
| |
| static char * /* O - Filename or NULL */ |
| get_printer_ppd(const char *uri, /* I - Printer URI */ |
| char *buffer, /* I - Filename buffer */ |
| size_t bufsize) /* I - Size of filename buffer */ |
| { |
| http_t *http; /* Connection to printer */ |
| ipp_t *request, /* Get-Printer-Attributes request */ |
| *response; /* Get-Printer-Attributes response */ |
| char resolved[1024], /* Resolved URI */ |
| scheme[32], /* URI scheme */ |
| userpass[256], /* Username:password */ |
| host[256], /* Hostname */ |
| resource[256]; /* Resource path */ |
| int port; /* Port number */ |
| static const char * const pattrs[] = /* Printer attributes we need */ |
| { |
| "all", |
| "media-col-database" |
| }; |
| |
| |
| /* |
| * Connect to the printer... |
| */ |
| |
| if (strstr(uri, "._tcp")) |
| { |
| /* |
| * Resolve URI... |
| */ |
| |
| if (!_httpResolveURI(uri, resolved, sizeof(resolved), _HTTP_RESOLVE_DEFAULT, NULL, NULL)) |
| { |
| fprintf(stderr, "ERROR: Unable to resolve \"%s\".\n", uri); |
| return (NULL); |
| } |
| |
| uri = resolved; |
| } |
| |
| if (httpSeparateURI(HTTP_URI_CODING_ALL, uri, scheme, sizeof(scheme), userpass, sizeof(userpass), host, sizeof(host), &port, resource, sizeof(resource)) < HTTP_URI_STATUS_OK) |
| { |
| fprintf(stderr, "ERROR: Bad printer URI \"%s\".\n", uri); |
| return (NULL); |
| } |
| |
| http = httpConnect2(host, port, NULL, AF_UNSPEC, !strcmp(scheme, "ipps") ? HTTP_ENCRYPTION_ALWAYS : HTTP_ENCRYPTION_IF_REQUESTED, 1, 30000, NULL); |
| if (!http) |
| { |
| fprintf(stderr, "ERROR: Unable to connect to \"%s:%d\": %s\n", host, port, cupsLastErrorString()); |
| return (NULL); |
| } |
| |
| /* |
| * Send a Get-Printer-Attributes request... |
| */ |
| |
| request = ippNewRequest(IPP_OP_GET_PRINTER_ATTRIBUTES); |
| ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri); |
| ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, "requested-attributes", (int)(sizeof(pattrs) / sizeof(pattrs[0])), NULL, pattrs); |
| response = cupsDoRequest(http, request, resource); |
| |
| if (!_ppdCreateFromIPP(buffer, bufsize, response)) |
| fprintf(stderr, "ERROR: Unable to create PPD file: %s\n", strerror(errno)); |
| |
| ippDelete(response); |
| httpClose(http); |
| |
| if (buffer[0]) |
| return (buffer); |
| else |
| return (NULL); |
| } |