static const char *iprint_server(void) { if ((lp_iprint_server() != NULL) && (strlen(lp_iprint_server()) > 0)) { DEBUG(10, ("iprint server explicitly set to %s\n", lp_iprint_server())); return lp_iprint_server(); } DEBUG(10, ("iprint server left to default %s\n", cupsServer())); return cupsServer(); }
/* This function allocates new instance of GtkCupsConnectionTest() and creates * a socket for communication with a CUPS server 'server'. */ GtkCupsConnectionTest * gtk_cups_connection_test_new (const char *server, const int port) { GtkCupsConnectionTest *result = NULL; gchar *port_str = NULL; result = g_new (GtkCupsConnectionTest, 1); if (port >= 0) port_str = g_strdup_printf ("%d", port); else port_str = g_strdup_printf ("%d", ippPort ()); if (server != NULL) result->addrlist = httpAddrGetList (server, AF_UNSPEC, port_str); else result->addrlist = httpAddrGetList (cupsServer (), AF_UNSPEC, port_str); g_free (port_str); result->socket = -1; result->current_addr = NULL; result->last_wrong_addr = NULL; result->at_init = GTK_CUPS_CONNECTION_NOT_AVAILABLE; result->at_init = gtk_cups_connection_test_get_state (result); return result; }
int getPrinterSharingStatus() { http_t* cups = nullptr; int num_settings = 0; cups_option_t* settings = nullptr; const char* value = nullptr; cups = httpConnect2(cupsServer(), ippPort(), nullptr, AF_INET, cupsEncryption(), 1, 30000, nullptr); if (cups == nullptr) { return 0; } int ret = cupsAdminGetServerSettings(cups, &num_settings, &settings); if (ret != 0) { value = cupsGetOption("_share_printers", num_settings, settings); cupsFreeOptions(num_settings, settings); } else { VLOG(1) << "Unable to get CUPS server settings: " << cupsLastErrorString(); } httpClose(cups); if (value != nullptr) { return *value == '1' ? 1 : 0; } return 0; }
/* * call-seq: * PrintJob.new(filename, printer=nil) * * Initializes a new PrintJob object. If no target printer/class is specified, the default is chosen. * Note the specified file does not have to exist until print is called. */ static VALUE job_init(int argc, VALUE* argv, VALUE self) { VALUE filename, printer, job_options; rb_scan_args(argc, argv, "12", &filename, &printer, &job_options); rb_iv_set(self, "@filename", filename); rb_iv_set(self, "@url_path", rb_str_new2(cupsServer())); if (NIL_P(job_options)) { rb_iv_set(self, "@job_options", rb_hash_new()); } else { rb_iv_set(self, "@job_options", job_options); } if (NIL_P(printer)) { // Fall back to default printer VALUE def_p = rb_funcall(rubyCups, rb_intern("default_printer"), 0); if (def_p == Qfalse) { rb_raise(rb_eRuntimeError, "There is no default printer!"); } else { rb_iv_set(self, "@printer", def_p); } } else { if (printer_exists(printer)) { rb_iv_set(self, "@printer", printer); } else { rb_raise(rb_eRuntimeError, "The printer or destination doesn't exist!"); } } return self; }
int /* O - Exit status */ main(int argc, /* I - Number of command-line args */ char *argv[]) /* I - Command-line arguments */ { int i, /* Looping var */ num_settings; /* Number of settings */ cups_option_t *settings; /* Settings */ http_t *http; /* Connection to server */ /* * Connect to the server using the defaults... */ http = httpConnect2(cupsServer(), ippPort(), NULL, AF_UNSPEC, cupsEncryption(), 1, 30000, NULL); /* * Set the current configuration if we have anything on the command-line... */ if (argc > 1) { for (i = 1, num_settings = 0, settings = NULL; i < argc; i ++) num_settings = cupsParseOptions(argv[i], num_settings, &settings); if (cupsAdminSetServerSettings(http, num_settings, settings)) { puts("New server settings:"); cupsFreeOptions(num_settings, settings); } else { printf("Server settings not changed: %s\n", cupsLastErrorString()); return (1); } } else puts("Current server settings:"); /* * Get the current configuration... */ if (cupsAdminGetServerSettings(http, &num_settings, &settings)) { show_settings(num_settings, settings); cupsFreeOptions(num_settings, settings); return (0); } else { printf(" %s\n", cupsLastErrorString()); return (1); } }
static rdpPrintJob* printer_cups_create_printjob(rdpPrinter* printer, UINT32 id) { rdpCupsPrinter* cups_printer = (rdpCupsPrinter*) printer; rdpCupsPrintJob* cups_printjob; if (cups_printer->printjob != NULL) return NULL; cups_printjob = (rdpCupsPrintJob*) malloc(sizeof(rdpCupsPrintJob)); ZeroMemory(cups_printjob, sizeof(rdpCupsPrintJob)); cups_printjob->printjob.id = id; cups_printjob->printjob.printer = printer; cups_printjob->printjob.Write = printer_cups_write_printjob; cups_printjob->printjob.Close = printer_cups_close_printjob; #ifndef _CUPS_API_1_4 cups_printjob->printjob_object = _strdup(tmpnam(NULL)); #else { char buf[100]; cups_printjob->printjob_object = httpConnectEncrypt(cupsServer(), ippPort(), HTTP_ENCRYPT_IF_REQUESTED); if (cups_printjob->printjob_object == NULL) { DEBUG_WARN("httpConnectEncrypt: %s", cupsLastErrorString()); free(cups_printjob); return NULL; } printer_cups_get_printjob_name(buf, sizeof(buf)); cups_printjob->printjob_id = cupsCreateJob((http_t*) cups_printjob->printjob_object, printer->name, buf, 0, NULL); if (cups_printjob->printjob_id == 0) { DEBUG_WARN("cupsCreateJob: %s", cupsLastErrorString()); httpClose((http_t*) cups_printjob->printjob_object); free(cups_printjob); return NULL; } cupsStartDocument((http_t*) cups_printjob->printjob_object, printer->name, cups_printjob->printjob_id, buf, CUPS_FORMAT_AUTO, 1); } #endif cups_printer->printjob = cups_printjob; return (rdpPrintJob*)cups_printjob; }
uint32 printer_hw_create(IRP * irp, const char * path) { PRINTER_DEVICE_INFO * info; info = (PRINTER_DEVICE_INFO *) irp->dev->info; /* Server's print queue will ensure no two print jobs will be sent to the same printer. However, we still want to do a simple locking just to ensure we are safe. */ if (info->printjob_object) { return RD_STATUS_DEVICE_BUSY; } #ifndef _CUPS_API_1_4 info->printjob_id++; info->printjob_object = strdup(tmpnam(NULL)); #else { char buf[100]; info->printjob_object = httpConnectEncrypt(cupsServer(), ippPort(), HTTP_ENCRYPT_IF_REQUESTED); if (info->printjob_object == NULL) { LLOGLN(0, ("printer_hw_create: httpConnectEncrypt: %s", cupsLastErrorString())); return RD_STATUS_DEVICE_BUSY; } printer_hw_get_printjob_name(buf, sizeof(buf)); info->printjob_id = cupsCreateJob((http_t *) info->printjob_object, info->printer_name, buf, 0, NULL); if (info->printjob_id == 0) { LLOGLN(0, ("printer_hw_create: cupsCreateJob: %s", cupsLastErrorString())); httpClose((http_t *) info->printjob_object); info->printjob_object = NULL; /* Should get the right return code based on printer status */ return RD_STATUS_DEVICE_BUSY; } cupsStartDocument((http_t *) info->printjob_object, info->printer_name, info->printjob_id, buf, CUPS_FORMAT_POSTSCRIPT, 1); } #endif LLOGLN(10, ("printe_hw_create: %s id=%d", info->printer_name, info->printjob_id)); irp->fileID = info->printjob_id; return RD_STATUS_SUCCESS; }
static http_t *cups_connect(TALLOC_CTX *frame) { http_t *http = NULL; char *server = NULL, *p = NULL; int port; int timeout = lp_cups_connection_timeout(); size_t size; if (lp_cups_server(talloc_tos()) != NULL && strlen(lp_cups_server(talloc_tos())) > 0) { if (!push_utf8_talloc(frame, &server, lp_cups_server(talloc_tos()), &size)) { return NULL; } } else { server = talloc_strdup(frame,cupsServer()); } if (!server) { return NULL; } p = strchr(server, ':'); if (p) { port = atoi(p+1); *p = '\0'; } else { port = ippPort(); } DEBUG(10, ("connecting to cups server %s:%d\n", server, port)); gotalarm = 0; if (timeout) { CatchSignal(SIGALRM, gotalarm_sig); alarm(timeout); } #ifdef HAVE_HTTPCONNECTENCRYPT http = httpConnectEncrypt(server, port, lp_cups_encrypt()); #else http = httpConnect(server, port); #endif CatchSignal(SIGALRM, SIG_IGN); alarm(0); if (http == NULL) { DEBUG(0,("Unable to connect to CUPS server %s:%d - %s\n", server, port, strerror(errno))); } return http; }
http_t * oyGetCUPSConnection() { if(!cups_http_) { httpInitialize(); /* Open access to printer(s) installed on system. */ cups_http_ = httpConnectEncrypt ( cupsServer(), ippPort(), cupsEncryption()); } return cups_http_; }
static void connection_test_thread (GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable) { http_t *http; http = httpConnectEncrypt (cupsServer (), ippPort (), cupsEncryption ()); g_task_return_boolean (task, http != NULL); httpClose (http); }
static int GetCupsPrinters(char ***printer) { http_t *http=NULL; /* HTTP object */ ipp_t *request=NULL; /* IPP request object */ ipp_t *response=NULL; /* IPP response object */ ipp_attribute_t *attr; /* Current IPP attribute */ int cnt=0; /* Connect to the HTTP server */ if ((http = httpConnectEncrypt(cupsServer(), ippPort(), cupsEncryption())) == NULL) goto bugout; /* Assemble the IPP request */ request = ippNew(); ippSetOperation( request, CUPS_GET_PRINTERS ); ippSetRequestId( request, 1 ); ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET, "attributes-charset", NULL, "utf-8"); ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE, "attributes-natural-language", NULL, "en"); ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, "requested-attributes", NULL, "device-uri"); /* Send the request and get a response. */ if ((response = cupsDoRequest(http, request, "/")) == NULL) goto bugout; for (attr = ippFirstAttribute ( response ); attr != NULL; attr = ippNextAttribute( response )) { /* Skip leading attributes until we hit a printer. */ while (attr != NULL && ippGetGroupTag( attr ) != IPP_TAG_PRINTER) attr = ippNextAttribute( response ); if (attr == NULL) break; while (attr != NULL && ippGetGroupTag( attr ) == IPP_TAG_PRINTER) { if (strcmp(ippGetName( attr ), "device-uri") == 0 && ippGetValueTag( attr ) == IPP_TAG_URI && AddCupsList(ippGetString( attr, 0, NULL ), printer) == 0) cnt++; attr = ippNextAttribute( response ); } if (attr == NULL) break; } ippDelete(response); bugout: return cnt; }
/* * Gets CUPS server name. * */ JNIEXPORT jstring JNICALL Java_sun_print_CUPSPrinter_getCupsServer(JNIEnv *env, jobject printObj) { jstring cServer = NULL; const char* server = cupsServer(); if (server != NULL) { // Is this a local domain socket? if (strncmp(server, "/", 1) == 0) { cServer = JNU_NewStringPlatform(env, "localhost"); } else { cServer = JNU_NewStringPlatform(env, server); } } return cServer; }
static http_t * /* O - New HTTP connection */ connect_server(const char *command, /* I - Command name */ http_t *http) /* I - Current HTTP connection */ { if (!http) { http = httpConnectEncrypt(cupsServer(), ippPort(), cupsEncryption()); if (http == NULL) { _cupsLangPrintf(stderr, _("%s: Unable to connect to server."), command); exit(1); } } return (http); }
int /* O - Exit status */ main(int argc, /* I - Number of command-line arguments */ char *argv[]) /* I - Command-line arguments */ { http_t *http; /* HTTP connection to server */ int i; /* Looping var */ int job_id; /* Job ID */ int num_dests; /* Number of destinations */ cups_dest_t *dests; /* Destinations */ char *dest, /* Destination printer */ *job, /* Job ID pointer */ *user; /* Cancel jobs for a user */ int purge; /* Purge or cancel jobs? */ char uri[1024]; /* Printer or job URI */ ipp_t *request; /* IPP request */ ipp_t *response; /* IPP response */ ipp_op_t op; /* Operation */ _cupsSetLocale(argv); /* * Setup to cancel individual print jobs... */ op = IPP_CANCEL_JOB; purge = 0; dest = NULL; user = NULL; http = NULL; num_dests = 0; dests = NULL; /* * Process command-line arguments... */ for (i = 1; i < argc; i ++) if (argv[i][0] == '-' && argv[i][1]) switch (argv[i][1]) { case 'E' : /* Encrypt */ #ifdef HAVE_SSL cupsSetEncryption(HTTP_ENCRYPT_REQUIRED); if (http) httpEncryption(http, HTTP_ENCRYPT_REQUIRED); #else _cupsLangPrintf(stderr, _("%s: Sorry, no encryption support compiled in!\n"), argv[0]); #endif /* HAVE_SSL */ break; case 'U' : /* Username */ if (argv[i][2] != '\0') cupsSetUser(argv[i] + 2); else { i ++; if (i >= argc) { _cupsLangPrintf(stderr, _("%s: Error - expected username after " "\'-U\' option!\n"), argv[0]); return (1); } cupsSetUser(argv[i]); } break; case 'a' : /* Cancel all jobs */ purge = 1; op = IPP_PURGE_JOBS; break; case 'h' : /* Connect to host */ if (http != NULL) { httpClose(http); http = NULL; } if (argv[i][2] != '\0') cupsSetServer(argv[i] + 2); else { i ++; if (i >= argc) { _cupsLangPrintf(stderr, _("%s: Error - expected hostname after " "\'-h\' option!\n"), argv[0]); return (1); } else cupsSetServer(argv[i]); } break; case 'u' : /* Username */ op = IPP_PURGE_JOBS; if (argv[i][2] != '\0') user = argv[i] + 2; else { i ++; if (i >= argc) { _cupsLangPrintf(stderr, _("%s: Error - expected username after " "\'-u\' option!\n"), argv[0]); return (1); } else user = argv[i]; } break; default : _cupsLangPrintf(stderr, _("%s: Error - unknown option \'%c\'!\n"), argv[0], argv[i][1]); return (1); } else { /* * Cancel a job or printer... */ if (num_dests == 0) num_dests = cupsGetDests(&dests); if (!strcmp(argv[i], "-")) { /* * Delete the current job... */ dest = ""; job_id = 0; } else if (cupsGetDest(argv[i], NULL, num_dests, dests) != NULL) { /* * Delete the current job on the named destination... */ dest = argv[i]; job_id = 0; } else if ((job = strrchr(argv[i], '-')) != NULL && isdigit(job[1] & 255)) { /* * Delete the specified job ID. */ dest = NULL; op = IPP_CANCEL_JOB; job_id = atoi(job + 1); } else if (isdigit(argv[i][0] & 255)) { /* * Delete the specified job ID. */ dest = NULL; op = IPP_CANCEL_JOB; job_id = atoi(argv[i]); } else { /* * Bad printer name! */ _cupsLangPrintf(stderr, _("%s: Error - unknown destination \"%s\"!\n"), argv[0], argv[i]); return (1); } /* * For Solaris LP compatibility, ignore a destination name after * cancelling a specific job ID... */ if (job_id && (i + 1) < argc && cupsGetDest(argv[i + 1], NULL, num_dests, dests) != NULL) i ++; /* * Open a connection to the server... */ if (http == NULL) if ((http = httpConnectEncrypt(cupsServer(), ippPort(), cupsEncryption())) == NULL) { _cupsLangPrintf(stderr, _("%s: Unable to contact server!\n"), argv[0]); return (1); } /* * Build an IPP request, which requires the following * attributes: * * attributes-charset * attributes-natural-language * printer-uri + job-id *or* job-uri * [requesting-user-name] */ request = ippNewRequest(op); if (dest) { httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL, "localhost", 0, "/printers/%s", dest); ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri); ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id", job_id); } else { sprintf(uri, "ipp://localhost/jobs/%d", job_id); ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL, uri); } if (user) { ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", NULL, user); ippAddBoolean(request, IPP_TAG_OPERATION, "my-jobs", 1); } else ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", NULL, cupsUser()); if (op == IPP_PURGE_JOBS) ippAddBoolean(request, IPP_TAG_OPERATION, "purge-jobs", purge); /* * Do the request and get back a response... */ if (op == IPP_PURGE_JOBS && (!user || strcasecmp(user, cupsUser()))) response = cupsDoRequest(http, request, "/admin/"); else response = cupsDoRequest(http, request, "/jobs/"); if (response == NULL || response->request.status.status_code > IPP_OK_CONFLICT) { _cupsLangPrintf(stderr, _("%s: %s failed: %s\n"), argv[0], op == IPP_PURGE_JOBS ? "purge-jobs" : "cancel-job", cupsLastErrorString()); if (response) ippDelete(response); return (1); } ippDelete(response); } if (num_dests == 0 && op == IPP_PURGE_JOBS) { /* * Open a connection to the server... */ if (http == NULL) if ((http = httpConnectEncrypt(cupsServer(), ippPort(), cupsEncryption())) == NULL) { _cupsLangPrintf(stderr, _("%s: Unable to contact server!\n"), argv[0]); return (1); } /* * Build an IPP request, which requires the following * attributes: * * attributes-charset * attributes-natural-language * printer-uri + job-id *or* job-uri * [requesting-user-name] */ request = ippNewRequest(op); ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, "ipp://localhost/printers/"); if (user) { ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", NULL, user); ippAddBoolean(request, IPP_TAG_OPERATION, "my-jobs", 1); } else ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", NULL, cupsUser()); ippAddBoolean(request, IPP_TAG_OPERATION, "purge-jobs", purge); /* * Do the request and get back a response... */ response = cupsDoRequest(http, request, "/admin/"); if (response == NULL || response->request.status.status_code > IPP_OK_CONFLICT) { _cupsLangPrintf(stderr, _("%s: %s failed: %s\n"), argv[0], op == IPP_PURGE_JOBS ? "purge-jobs" : "cancel-job", cupsLastErrorString()); if (response) ippDelete(response); return (1); } ippDelete(response); } return (0); }
int /* O - Exit status */ main(int argc, /* I - Number of command-line arguments */ char *argv[]) /* I - Command-line arguments */ { const char *printer; /* Printer name */ const char *user; /* Username */ http_t *http; /* Connection to the server */ ipp_t *request, /* IPP request */ *response; /* IPP response */ ipp_attribute_t *attr; /* IPP attribute */ const char *op; /* Operation to perform, if any */ static const char *def_attrs[] = /* Attributes for default printer */ { "printer-name", "printer-uri-supported" }; /* * Get any form variables... */ cgiInitialize(); op = cgiGetVariable("OP"); /* * Set the web interface section... */ cgiSetVariable("SECTION", "printers"); cgiSetVariable("REFRESH_PAGE", ""); /* * See if we are displaying a printer or all printers... */ if ((printer = getenv("PATH_INFO")) != NULL) { printer ++; if (!*printer) printer = NULL; if (printer) cgiSetVariable("PRINTER_NAME", printer); } /* * See who is logged in... */ user = getenv("REMOTE_USER"); /* * Connect to the HTTP server... */ http = httpConnectEncrypt(cupsServer(), ippPort(), cupsEncryption()); /* * Get the default printer... */ if (!op || !cgiIsPOST()) { /* * Get the default destination... */ request = ippNewRequest(CUPS_GET_DEFAULT); ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, "requested-attributes", sizeof(def_attrs) / sizeof(def_attrs[0]), NULL, def_attrs); if ((response = cupsDoRequest(http, request, "/")) != NULL) { if ((attr = ippFindAttribute(response, "printer-name", IPP_TAG_NAME)) != NULL) cgiSetVariable("DEFAULT_NAME", attr->values[0].string.text); if ((attr = ippFindAttribute(response, "printer-uri-supported", IPP_TAG_URI)) != NULL) { char url[HTTP_MAX_URI]; /* New URL */ cgiSetVariable("DEFAULT_URI", cgiRewriteURL(attr->values[0].string.text, url, sizeof(url), NULL)); } ippDelete(response); } /* * See if we need to show a list of printers or the status of a * single printer... */ if (!printer) show_all_printers(http, user); else show_printer(http, printer); } else if (printer) { if (!*op) { const char *server_port = getenv("SERVER_PORT"); /* Port number string */ int port = atoi(server_port ? server_port : "0"); /* Port number */ char uri[1024]; /* URL */ httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), getenv("HTTPS") ? "https" : "http", NULL, getenv("SERVER_NAME"), port, "/printers/%s", printer); printf("Location: %s\n\n", uri); } else if (!strcmp(op, "start-printer")) do_printer_op(http, printer, IPP_RESUME_PRINTER, cgiText(_("Resume Printer"))); else if (!strcmp(op, "stop-printer")) do_printer_op(http, printer, IPP_PAUSE_PRINTER, cgiText(_("Pause Printer"))); else if (!strcmp(op, "accept-jobs")) do_printer_op(http, printer, CUPS_ACCEPT_JOBS, cgiText(_("Accept Jobs"))); else if (!strcmp(op, "reject-jobs")) do_printer_op(http, printer, CUPS_REJECT_JOBS, cgiText(_("Reject Jobs"))); else if (!strcmp(op, "purge-jobs")) do_printer_op(http, printer, IPP_PURGE_JOBS, cgiText(_("Purge Jobs"))); else if (!_cups_strcasecmp(op, "print-self-test-page")) cgiPrintCommand(http, printer, "PrintSelfTestPage", cgiText(_("Print Self-Test Page"))); else if (!_cups_strcasecmp(op, "clean-print-heads")) cgiPrintCommand(http, printer, "Clean all", cgiText(_("Clean Print Heads"))); else if (!_cups_strcasecmp(op, "print-test-page")) cgiPrintTestPage(http, printer); else if (!_cups_strcasecmp(op, "move-jobs")) cgiMoveJobs(http, printer, 0); else { /* * Unknown/bad operation... */ cgiStartHTML(printer); cgiCopyTemplateLang("error-op.tmpl"); cgiEndHTML(); } } else { /* * Unknown/bad operation... */ cgiStartHTML(cgiText(_("Printers"))); cgiCopyTemplateLang("error-op.tmpl"); cgiEndHTML(); } /* * Close the HTTP server connection... */ httpClose(http); /* * Return with no errors... */ return (0); }
http_t * /* O - HTTP connection */ _cupsConnect(void) { _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */ /* * See if we are connected to the same server... */ if (cg->http) { /* * Compare the connection hostname, port, and encryption settings to * the cached defaults; these were initialized the first time we * connected... */ if (strcmp(cg->http->hostname, cg->server) || cg->ipp_port != httpAddrPort(cg->http->hostaddr) || (cg->http->encryption != cg->encryption && cg->http->encryption == HTTP_ENCRYPTION_NEVER)) { /* * Need to close the current connection because something has changed... */ httpClose(cg->http); cg->http = NULL; } else { /* * Same server, see if the connection is still established... */ char ch; /* Connection check byte */ ssize_t n; /* Number of bytes */ #ifdef WIN32 if ((n = recv(cg->http->fd, &ch, 1, MSG_PEEK)) == 0 || (n < 0 && WSAGetLastError() != WSAEWOULDBLOCK)) #else if ((n = recv(cg->http->fd, &ch, 1, MSG_PEEK | MSG_DONTWAIT)) == 0 || (n < 0 && errno != EWOULDBLOCK)) #endif /* WIN32 */ { /* * Nope, close the connection... */ httpClose(cg->http); cg->http = NULL; } } } /* * (Re)connect as needed... */ if (!cg->http) { if ((cg->http = httpConnect2(cupsServer(), ippPort(), NULL, AF_UNSPEC, cupsEncryption(), 1, 30000, NULL)) == NULL) { if (errno) _cupsSetError(IPP_STATUS_ERROR_SERVICE_UNAVAILABLE, NULL, 0); else _cupsSetError(IPP_STATUS_ERROR_SERVICE_UNAVAILABLE, _("Unable to connect to host."), 1); } } /* * Return the cached connection... */ return (cg->http); }
static int /* O - Command status */ recv_print_job( const char *queue, /* I - Printer name */ int num_defaults, /* I - Number of default options */ cups_option_t *defaults) /* I - Default options */ { http_t *http; /* HTTP connection */ int i; /* Looping var */ int status; /* Command status */ int fd; /* Temporary file */ FILE *fp; /* File pointer */ char filename[1024]; /* Temporary filename */ ssize_t bytes; /* Bytes received */ size_t total; /* Total bytes */ char line[256], /* Line from file/stdin */ command, /* Command from line */ *count, /* Number of bytes */ *name; /* Name of file */ const char *job_sheets; /* Job sheets */ int num_data; /* Number of data files */ char control[1024], /* Control filename */ data[100][256], /* Data files */ temp[100][1024]; /* Temporary files */ char user[1024], /* User name */ title[1024], /* Job title */ docname[1024], /* Document name */ dest[256]; /* Printer/class queue */ int accepting, /* printer-is-accepting */ shared, /* printer-is-shared */ num_options; /* Number of options */ cups_option_t *options; /* Options */ int id; /* Job ID */ int docnumber, /* Current document number */ doccount; /* Count of documents */ /* * Connect to the server... */ http = httpConnectEncrypt(cupsServer(), ippPort(), cupsEncryption()); if (!http) { syslog(LOG_ERR, "Unable to connect to server: %s", strerror(errno)); putchar(1); return (1); } /* * See if the printer is available... */ num_options = get_printer(http, queue, dest, sizeof(dest), &options, &accepting, &shared, NULL); if (num_options < 0 || !accepting || !shared) { if (dest[0]) syslog(LOG_INFO, "Rejecting job because \"%s\" is not %s", dest, !accepting ? "accepting jobs" : "shared"); else syslog(LOG_ERR, "Unable to get printer information for \"%s\"", queue); httpClose(http); putchar(1); return (1); } putchar(0); /* OK so far... */ /* * Read the request... */ status = 0; num_data = 0; fd = -1; control[0] = '\0'; while (smart_gets(line, sizeof(line), stdin) != NULL) { if (strlen(line) < 2) { status = 1; break; } command = line[0]; count = line + 1; for (name = count + 1; *name && !isspace(*name & 255); name ++); while (isspace(*name & 255)) *name++ = '\0'; switch (command) { default : case 0x01 : /* Abort */ status = 1; break; case 0x02 : /* Receive control file */ if (strlen(name) < 2) { syslog(LOG_ERR, "Bad control file name \"%s\"", name); putchar(1); status = 1; break; } if (control[0]) { /* * Append to the existing control file - the LPD spec is * not entirely clear, but at least the OS/2 LPD code sends * multiple control files per connection... */ if ((fd = open(control, O_WRONLY)) < 0) { syslog(LOG_ERR, "Unable to append to temporary control file \"%s\" - %s", control, strerror(errno)); putchar(1); status = 1; break; } lseek(fd, 0, SEEK_END); } else { if ((fd = cupsTempFd(control, sizeof(control))) < 0) { syslog(LOG_ERR, "Unable to open temporary control file \"%s\" - %s", control, strerror(errno)); putchar(1); status = 1; break; } strlcpy(filename, control, sizeof(filename)); } break; case 0x03 : /* Receive data file */ if (strlen(name) < 2) { syslog(LOG_ERR, "Bad data file name \"%s\"", name); putchar(1); status = 1; break; } if (num_data >= (int)(sizeof(data) / sizeof(data[0]))) { /* * Too many data files... */ syslog(LOG_ERR, "Too many data files (%d)", num_data); putchar(1); status = 1; break; } strlcpy(data[num_data], name, sizeof(data[0])); if ((fd = cupsTempFd(temp[num_data], sizeof(temp[0]))) < 0) { syslog(LOG_ERR, "Unable to open temporary data file \"%s\" - %s", temp[num_data], strerror(errno)); putchar(1); status = 1; break; } strlcpy(filename, temp[num_data], sizeof(filename)); num_data ++; break; } putchar(status); if (status) break; /* * Copy the data or control file from the client... */ for (total = (size_t)strtoll(count, NULL, 10); total > 0; total -= (size_t)bytes) { if (total > sizeof(line)) bytes = (ssize_t)sizeof(line); else bytes = (ssize_t)total; if ((bytes = (ssize_t)fread(line, 1, (size_t)bytes, stdin)) > 0) bytes = write(fd, line, (size_t)bytes); if (bytes < 1) { syslog(LOG_ERR, "Error while reading file - %s", strerror(errno)); status = 1; break; } } /* * Read trailing nul... */ if (!status) { if (fread(line, 1, 1, stdin) < 1) { status = 1; syslog(LOG_ERR, "Error while reading trailing nul - %s", strerror(errno)); } else if (line[0]) { status = 1; syslog(LOG_ERR, "Trailing character after file is not nul (%02X)!", line[0]); } } /* * Close the file and send an acknowledgement... */ close(fd); putchar(status); if (status) break; } if (!status) { /* * Process the control file and print stuff... */ if ((fp = fopen(control, "rb")) == NULL) status = 1; else { /* * Copy the default options... */ for (i = 0; i < num_defaults; i ++) num_options = cupsAddOption(defaults[i].name, defaults[i].value, num_options, &options); /* * Grab the job information... */ title[0] = '\0'; user[0] = '\0'; docname[0] = '\0'; doccount = 0; while (smart_gets(line, sizeof(line), fp) != NULL) { /* * Process control lines... */ switch (line[0]) { case 'J' : /* Job name */ strlcpy(title, line + 1, sizeof(title)); break; case 'N' : /* Document name */ strlcpy(docname, line + 1, sizeof(docname)); break; case 'P' : /* User identification */ strlcpy(user, line + 1, sizeof(user)); break; case 'L' : /* Print banner page */ /* * If a banner was requested and it's not overridden by a * command line option and the destination's default is none * then add the standard banner... */ if (cupsGetOption("job-sheets", num_defaults, defaults) == NULL && ((job_sheets = cupsGetOption("job-sheets", num_options, options)) == NULL || !strcmp(job_sheets, "none,none"))) { num_options = cupsAddOption("job-sheets", "standard", num_options, &options); } break; case 'c' : /* Plot CIF file */ case 'd' : /* Print DVI file */ case 'f' : /* Print formatted file */ case 'g' : /* Plot file */ case 'l' : /* Print file leaving control characters (raw) */ case 'n' : /* Print ditroff output file */ case 'o' : /* Print PostScript output file */ case 'p' : /* Print file with 'pr' format (prettyprint) */ case 'r' : /* File to print with FORTRAN carriage control */ case 't' : /* Print troff output file */ case 'v' : /* Print raster file */ doccount ++; if (line[0] == 'l' && !cupsGetOption("document-format", num_options, options)) num_options = cupsAddOption("raw", "", num_options, &options); if (line[0] == 'p') num_options = cupsAddOption("prettyprint", "", num_options, &options); break; } if (status) break; } /* * Check that we have a username... */ if (!user[0]) { syslog(LOG_WARNING, "No username specified by client! " "Using \"anonymous\"..."); strlcpy(user, "anonymous", sizeof(user)); } /* * Create the job... */ if ((id = create_job(http, dest, title, docname, user, num_options, options)) < 0) status = 1; else { /* * Then print the job files... */ rewind(fp); docname[0] = '\0'; docnumber = 0; while (smart_gets(line, sizeof(line), fp) != NULL) { /* * Process control lines... */ switch (line[0]) { case 'N' : /* Document name */ strlcpy(docname, line + 1, sizeof(docname)); break; case 'c' : /* Plot CIF file */ case 'd' : /* Print DVI file */ case 'f' : /* Print formatted file */ case 'g' : /* Plot file */ case 'l' : /* Print file leaving control characters (raw) */ case 'n' : /* Print ditroff output file */ case 'o' : /* Print PostScript output file */ case 'p' : /* Print file with 'pr' format (prettyprint) */ case 'r' : /* File to print with FORTRAN carriage control */ case 't' : /* Print troff output file */ case 'v' : /* Print raster file */ /* * Figure out which file we are printing... */ for (i = 0; i < num_data; i ++) if (!strcmp(data[i], line + 1)) break; if (i >= num_data) { status = 1; break; } /* * Send the print file... */ docnumber ++; if (print_file(http, id, temp[i], docname, user, cupsGetOption("document-format", num_options, options), docnumber == doccount)) status = 1; else status = 0; break; } if (status) break; } } fclose(fp); } } cupsFreeOptions(num_options, options); httpClose(http); /* * Clean up all temporary files and return... */ unlink(control); for (i = 0; i < num_data; i ++) unlink(temp[i]); return (status); }
static int /* O - Command status */ send_state(const char *queue, /* I - Destination */ const char *list, /* I - Job or user */ int longstatus) /* I - List of jobs or users */ { int id; /* Job ID from list */ http_t *http; /* HTTP server connection */ ipp_t *request, /* IPP Request */ *response; /* IPP Response */ ipp_attribute_t *attr; /* Current attribute */ ipp_pstate_t state; /* Printer state */ const char *jobdest, /* Pointer into job-printer-uri */ *jobuser, /* Pointer to job-originating-user-name */ *jobname; /* Pointer to job-name */ ipp_jstate_t jobstate; /* job-state */ int jobid, /* job-id */ jobsize, /* job-k-octets */ jobcount, /* Number of jobs */ jobcopies, /* Number of copies */ rank; /* Rank of job */ char rankstr[255]; /* Rank string */ char namestr[1024]; /* Job name string */ char uri[HTTP_MAX_URI]; /* Printer URI */ char dest[256]; /* Printer/class queue */ static const char * const ranks[10] = /* Ranking strings */ { "th", "st", "nd", "rd", "th", "th", "th", "th", "th", "th" }; static const char * const requested[] = { /* Requested attributes */ "job-id", "job-k-octets", "job-state", "job-printer-uri", "job-originating-user-name", "job-name", "copies" }; /* * Try connecting to the local server... */ if ((http = httpConnectEncrypt(cupsServer(), ippPort(), cupsEncryption())) == NULL) { syslog(LOG_ERR, "Unable to connect to server %s: %s", cupsServer(), strerror(errno)); printf("Unable to connect to server %s: %s", cupsServer(), strerror(errno)); return (1); } /* * Get the actual destination name and printer state... */ if (get_printer(http, queue, dest, sizeof(dest), NULL, NULL, NULL, &state)) { syslog(LOG_ERR, "Unable to get printer %s: %s", queue, cupsLastErrorString()); printf("Unable to get printer %s: %s", queue, cupsLastErrorString()); return (1); } /* * Show the queue state... */ switch (state) { case IPP_PRINTER_IDLE : printf("%s is ready\n", dest); break; case IPP_PRINTER_PROCESSING : printf("%s is ready and printing\n", dest); break; case IPP_PRINTER_STOPPED : printf("%s is not ready\n", dest); break; } /* * Build an IPP_GET_JOBS or IPP_GET_JOB_ATTRIBUTES request, which requires * the following attributes: * * attributes-charset * attributes-natural-language * job-uri or printer-uri */ id = atoi(list); request = ippNewRequest(id ? IPP_GET_JOB_ATTRIBUTES : IPP_GET_JOBS); httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL, "localhost", 0, "/printers/%s", dest); ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri); if (id) ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id", id); else { ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", NULL, list); ippAddBoolean(request, IPP_TAG_OPERATION, "my-jobs", 1); } ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, "requested-attributes", sizeof(requested) / sizeof(requested[0]), NULL, requested); /* * Do the request and get back a response... */ jobcount = 0; response = cupsDoRequest(http, request, "/"); if (cupsLastError() > IPP_OK_CONFLICT) { printf("get-jobs failed: %s\n", cupsLastErrorString()); ippDelete(response); return (1); } /* * Loop through the job list and display them... */ for (attr = response->attrs, rank = 1; attr; attr = attr->next) { /* * Skip leading attributes until we hit a job... */ while (attr && (attr->group_tag != IPP_TAG_JOB || !attr->name)) attr = attr->next; if (!attr) break; /* * Pull the needed attributes from this job... */ jobid = 0; jobsize = 0; jobstate = IPP_JOB_PENDING; jobname = "untitled"; jobuser = NULL; jobdest = NULL; jobcopies = 1; while (attr && attr->group_tag == IPP_TAG_JOB) { if (!strcmp(attr->name, "job-id") && attr->value_tag == IPP_TAG_INTEGER) jobid = attr->values[0].integer; if (!strcmp(attr->name, "job-k-octets") && attr->value_tag == IPP_TAG_INTEGER) jobsize = attr->values[0].integer; if (!strcmp(attr->name, "job-state") && attr->value_tag == IPP_TAG_ENUM) jobstate = (ipp_jstate_t)attr->values[0].integer; if (!strcmp(attr->name, "job-printer-uri") && attr->value_tag == IPP_TAG_URI) if ((jobdest = strrchr(attr->values[0].string.text, '/')) != NULL) jobdest ++; if (!strcmp(attr->name, "job-originating-user-name") && attr->value_tag == IPP_TAG_NAME) jobuser = attr->values[0].string.text; if (!strcmp(attr->name, "job-name") && attr->value_tag == IPP_TAG_NAME) jobname = attr->values[0].string.text; if (!strcmp(attr->name, "copies") && attr->value_tag == IPP_TAG_INTEGER) jobcopies = attr->values[0].integer; attr = attr->next; } /* * See if we have everything needed... */ if (!jobdest || !jobid) { if (!attr) break; else continue; } if (!longstatus && jobcount == 0) puts("Rank Owner Job File(s) Total Size"); jobcount ++; /* * Display the job... */ if (jobstate == IPP_JOB_PROCESSING) strlcpy(rankstr, "active", sizeof(rankstr)); else { snprintf(rankstr, sizeof(rankstr), "%d%s", rank, ranks[rank % 10]); rank ++; } if (longstatus) { puts(""); if (jobcopies > 1) snprintf(namestr, sizeof(namestr), "%d copies of %s", jobcopies, jobname); else strlcpy(namestr, jobname, sizeof(namestr)); printf("%s: %-33.33s [job %d localhost]\n", jobuser, rankstr, jobid); printf(" %-39.39s %.0f bytes\n", namestr, 1024.0 * jobsize); } else printf("%-7s %-7.7s %-7d %-31.31s %.0f bytes\n", rankstr, jobuser, jobid, jobname, 1024.0 * jobsize); if (!attr) break; } ippDelete(response); if (jobcount == 0) puts("no entries"); httpClose(http); return (0); }
static int /* O - Command status */ remove_jobs(const char *dest, /* I - Destination */ const char *agent, /* I - User agent */ const char *list) /* I - List of jobs or users */ { int id; /* Job ID */ http_t *http; /* HTTP server connection */ ipp_t *request; /* IPP Request */ char uri[HTTP_MAX_URI]; /* Job URI */ (void)dest; /* Suppress compiler warnings... */ /* * Try connecting to the local server... */ if ((http = httpConnectEncrypt(cupsServer(), ippPort(), cupsEncryption())) == NULL) { syslog(LOG_ERR, "Unable to connect to server %s: %s", cupsServer(), strerror(errno)); return (1); } /* * Loop for each job... */ while ((id = atoi(list)) > 0) { /* * Skip job ID in list... */ while (isdigit(*list & 255)) list ++; while (isspace(*list & 255)) list ++; /* * Build an IPP_CANCEL_JOB request, which requires the following * attributes: * * attributes-charset * attributes-natural-language * job-uri * requesting-user-name */ request = ippNewRequest(IPP_CANCEL_JOB); sprintf(uri, "ipp://localhost/jobs/%d", id); ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL, uri); ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", NULL, agent); /* * Do the request and get back a response... */ ippDelete(cupsDoRequest(http, request, "/jobs")); if (cupsLastError() > IPP_OK_CONFLICT) { syslog(LOG_WARNING, "Cancel of job ID %d failed: %s\n", id, cupsLastErrorString()); httpClose(http); return (1); } else syslog(LOG_INFO, "Job ID %d canceled", id); } httpClose(http); return (0); }
int /* O - Exit status */ main(int argc, /* I - Number of command-line args */ char *argv[]) /* I - Command-line arguments */ { int i, /* Looping var */ num_settings; /* Number of settings */ cups_option_t *settings; /* Settings */ const char *opt; /* Current option character */ http_t *http; /* Connection to server */ /* * Process the command-line... */ _cupsSetLocale(argv); num_settings = 0; settings = NULL; for (i = 1; i < argc; i ++) { if (!strcmp(argv[i], "--help")) usage(NULL); else if (argv[i][0] == '-') { if (argv[i][1] == '-') { if (!strcmp(argv[i], "--debug-logging")) num_settings = cupsAddOption(CUPS_SERVER_DEBUG_LOGGING, "1", num_settings, &settings); else if (!strcmp(argv[i], "--no-debug-logging")) num_settings = cupsAddOption(CUPS_SERVER_DEBUG_LOGGING, "0", num_settings, &settings); else if (!strcmp(argv[i], "--remote-admin")) num_settings = cupsAddOption(CUPS_SERVER_REMOTE_ADMIN, "1", num_settings, &settings); else if (!strcmp(argv[i], "--no-remote-admin")) num_settings = cupsAddOption(CUPS_SERVER_REMOTE_ADMIN, "0", num_settings, &settings); else if (!strcmp(argv[i], "--remote-any")) num_settings = cupsAddOption(CUPS_SERVER_REMOTE_ANY, "1", num_settings, &settings); else if (!strcmp(argv[i], "--no-remote-any")) num_settings = cupsAddOption(CUPS_SERVER_REMOTE_ANY, "0", num_settings, &settings); else if (!strcmp(argv[i], "--share-printers")) num_settings = cupsAddOption(CUPS_SERVER_SHARE_PRINTERS, "1", num_settings, &settings); else if (!strcmp(argv[i], "--no-share-printers")) num_settings = cupsAddOption(CUPS_SERVER_SHARE_PRINTERS, "0", num_settings, &settings); else if (!strcmp(argv[i], "--user-cancel-any")) num_settings = cupsAddOption(CUPS_SERVER_USER_CANCEL_ANY, "1", num_settings, &settings); else if (!strcmp(argv[i], "--no-user-cancel-any")) num_settings = cupsAddOption(CUPS_SERVER_USER_CANCEL_ANY, "0", num_settings, &settings); else usage(argv[i]); } else { for (opt = argv[i] + 1; *opt; opt ++) switch (*opt) { case 'E' : cupsSetEncryption(HTTP_ENCRYPT_REQUIRED); break; case 'U' : i ++; if (i >= argc) usage(NULL); cupsSetUser(argv[i]); break; case 'h' : i ++; if (i >= argc) usage(NULL); cupsSetServer(argv[i]); break; default : usage(opt); break; } } } else if (strchr(argv[i], '=')) num_settings = cupsParseOptions(argv[i], num_settings, &settings); else usage(argv[i]); } if (cupsGetOption("Listen", num_settings, settings) || cupsGetOption("Port", num_settings, settings)) { _cupsLangPuts(stderr, _("cupsctl: Cannot set Listen or Port directly.")); return (1); } /* * Connect to the server using the defaults... */ if ((http = httpConnectEncrypt(cupsServer(), ippPort(), cupsEncryption())) == NULL) { _cupsLangPrintf(stderr, _("cupsctl: Unable to connect to server: %s"), strerror(errno)); return (1); } /* * Set the current configuration if we have anything on the command-line... */ if (num_settings > 0) { if (!cupsAdminSetServerSettings(http, num_settings, settings)) { _cupsLangPrintf(stderr, "cupsctl: %s", cupsLastErrorString()); return (1); } } else if (!cupsAdminGetServerSettings(http, &num_settings, &settings)) { _cupsLangPrintf(stderr, "cupsctl: %s", cupsLastErrorString()); return (1); } else { for (i = 0; i < num_settings; i ++) _cupsLangPrintf(stdout, "%s=%s", settings[i].name, settings[i].value); } cupsFreeOptions(num_settings, settings); return (0); }
/////////////////////////////////////////////////////////////////////////////////////////// // // CS : PRIVATE gint getPrinterURI(gchar *pDestName, gchar *pURI, gchar *pServerName, gint bufSize) // IN : gchar *pDestName : Printer name. // gint bufSize : Size of output buffer. // OUT : gchar *pURI : Printer URI. // gchar *pServerName : Server name. // RETURN : ID_ERR_NO_ERROR : No error. // ID_ERR_CUPS_API_FAILED : Error occured in CUPS API. // PRIVATE gint getPrinterURI(gchar *pDestName, gchar *pURI, gchar *pServerName, gint bufSize) { /*** Parameters start ***/ http_t *pHTTP; // Pointer to HTTP connection. ipp_t *pRequest, // Pointer to CUPS IPP request. *pResponse; // Pointer to CUPS IPP response. ipp_attribute_t *pAttribute; // Pointer to CUPS attributes. cups_lang_t *pLanguage; // Pointer to language. gchar *pPrinter = NULL; // Pointer to printer name. gchar *pUri = NULL; // Pointer to printer uri. gchar *pTemp = NULL; // Temporary pointer. gint i; // Counter. gint retVal = ID_ERR_NO_ERROR; // Return value. const char *attributes[] = { // Attributes name set. "printer-name", "printer-uri-supported", }; /*** Parameters end ***/ // CUPS http connect. if ((pHTTP = httpConnectEncrypt(cupsServer(), ippPort(), cupsEncryption())) == NULL) { retVal = ID_ERR_CUPS_API_FAILED; } else { pRequest = ippNew(); ippSetOperation(pRequest, CUPS_GET_PRINTERS); ippSetRequestId(pRequest, 1); pLanguage = bjcupsLangDefault(); // cupsLangDefault() -> bjcupsLangDefault() for cups-1.1.19 ippAddString(pRequest, IPP_TAG_OPERATION, IPP_TAG_CHARSET, "attributes-charset", NULL, cupsLangEncoding(pLanguage)); ippAddString(pRequest, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE, "attributes-natural-language", NULL, pLanguage->language); ippAddStrings(pRequest, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, "requested-attributes", sizeof(attributes) / sizeof(attributes[0]), NULL, attributes); if ((pResponse = cupsDoRequest(pHTTP, pRequest, "/")) != NULL) { if (ippGetStatusCode(pResponse) > IPP_OK_CONFLICT) { retVal = ID_ERR_CUPS_API_FAILED; } else { pAttribute = ippFirstAttribute(pResponse); while (pAttribute != NULL) { while (pAttribute != NULL && ippGetGroupTag(pAttribute) != IPP_TAG_PRINTER) { pAttribute = bjcups_ippNextAttribute(pRequest, pAttribute); } if (pAttribute == NULL) { break; } while (pAttribute != NULL && ippGetGroupTag(pAttribute) == IPP_TAG_PRINTER) { if (strcmp(ippGetName(pAttribute), "printer-name") == 0 && ippGetValueTag(pAttribute) == IPP_TAG_NAME) { pPrinter = ippGetString(pAttribute, 0, NULL); } if (strcmp(ippGetName(pAttribute), "printer-uri-supported") == 0 && ippGetValueTag(pAttribute) == IPP_TAG_URI) { pUri = ippGetString(pAttribute, 0, NULL); } pAttribute = bjcups_ippNextAttribute(pRequest, pAttribute); } // Tora 020418: Compare two printer names ignoring the character case. if (strcasecmp(pDestName, pPrinter) == 0) { strncpy(pURI, pUri, bufSize); pTemp = strstr(pURI, "//"); pTemp += 2; for (i = 0; *pTemp != '/' && *pTemp != ':'; i++, pTemp++) { pServerName[i] = *pTemp; } break; } if (pAttribute != NULL) pAttribute = bjcups_ippNextAttribute(pRequest, pAttribute); } } ippDelete(pResponse); } else { retVal = ID_ERR_CUPS_API_FAILED; } cupsLangFree(pLanguage); httpClose(pHTTP); } if (pURI[0] == '\0') { snprintf(pURI, bufSize, "ipp://localhost/printers/%s", pDestName); } if (pServerName[0] == '\0') { strncpy(pServerName, "localhost", strlen("localhost")); } return(retVal); }// End getPrinterURI
int /* O - 1 on success, 0 on failure */ cupsAdminGetServerSettings( http_t *http, /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */ int *num_settings, /* O - Number of settings */ cups_option_t **settings) /* O - Settings */ { int i; /* Looping var */ cups_file_t *cupsd; /* cupsd.conf file */ char cupsdconf[1024]; /* cupsd.conf filename */ int remote; /* Remote cupsd.conf file? */ http_status_t status; /* Status of getting cupsd.conf */ char line[1024], /* Line from cupsd.conf file */ *value; /* Value on line */ cups_option_t *setting; /* Current setting */ _cups_globals_t *cg = _cupsGlobals(); /* Global data */ /* * Range check input... */ if (!http) { /* * See if we are connected to the same server... */ if (cg->http) { /* * Compare the connection hostname, port, and encryption settings to * the cached defaults; these were initialized the first time we * connected... */ if (strcmp(cg->http->hostname, cg->server) || cg->ipp_port != httpAddrPort(cg->http->hostaddr) || (cg->http->encryption != cg->encryption && cg->http->encryption == HTTP_ENCRYPTION_NEVER)) { /* * Need to close the current connection because something has changed... */ httpClose(cg->http); cg->http = NULL; } } /* * (Re)connect as needed... */ if (!cg->http) { if ((cg->http = httpConnect2(cupsServer(), ippPort(), NULL, AF_UNSPEC, cupsEncryption(), 1, 0, NULL)) == NULL) { if (errno) _cupsSetError(IPP_STATUS_ERROR_SERVICE_UNAVAILABLE, NULL, 0); else _cupsSetError(IPP_STATUS_ERROR_SERVICE_UNAVAILABLE, _("Unable to connect to host."), 1); if (num_settings) *num_settings = 0; if (settings) *settings = NULL; return (0); } } http = cg->http; } if (!http || !num_settings || !settings) { _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(EINVAL), 0); if (num_settings) *num_settings = 0; if (settings) *settings = NULL; return (0); } *num_settings = 0; *settings = NULL; /* * Get the cupsd.conf file... */ if ((status = get_cupsd_conf(http, cg, cg->cupsd_update, cupsdconf, sizeof(cupsdconf), &remote)) == HTTP_STATUS_OK) { if ((cupsd = cupsFileOpen(cupsdconf, "r")) == NULL) { char message[1024]; /* Message string */ snprintf(message, sizeof(message), _cupsLangString(cupsLangDefault(), _("Open of %s failed: %s")), cupsdconf, strerror(errno)); _cupsSetError(IPP_STATUS_ERROR_INTERNAL, message, 0); } } else cupsd = NULL; if (cupsd) { /* * Read the file, keeping track of what settings are enabled... */ int remote_access = 0, /* Remote access allowed? */ remote_admin = 0, /* Remote administration allowed? */ remote_any = 0, /* Remote access from anywhere allowed? */ browsing = 1, /* Browsing enabled? */ cancel_policy = 1, /* Cancel-job policy set? */ debug_logging = 0; /* LogLevel debug set? */ int linenum = 0, /* Line number in file */ in_location = 0, /* In a location section? */ in_policy = 0, /* In a policy section? */ in_cancel_job = 0, /* In a cancel-job section? */ in_admin_location = 0; /* In the /admin location? */ invalidate_cupsd_cache(cg); cg->cupsd_update = time(NULL); httpGetHostname(http, cg->cupsd_hostname, sizeof(cg->cupsd_hostname)); while (cupsFileGetConf(cupsd, line, sizeof(line), &value, &linenum)) { if (!value && strncmp(line, "</", 2)) value = line + strlen(line); if ((!_cups_strcasecmp(line, "Port") || !_cups_strcasecmp(line, "Listen")) && value) { char *port; /* Pointer to port number, if any */ if ((port = strrchr(value, ':')) != NULL) *port = '\0'; else if (isdigit(*value & 255)) { /* * Listen on a port number implies remote access... */ remote_access = 1; continue; } if (_cups_strcasecmp(value, "localhost") && strcmp(value, "127.0.0.1") #ifdef AF_LOCAL && *value != '/' #endif /* AF_LOCAL */ #ifdef AF_INET6 && strcmp(value, "[::1]") #endif /* AF_INET6 */ ) remote_access = 1; } else if (!_cups_strcasecmp(line, "Browsing")) { browsing = !_cups_strcasecmp(value, "yes") || !_cups_strcasecmp(value, "on") || !_cups_strcasecmp(value, "true"); } else if (!_cups_strcasecmp(line, "LogLevel")) { debug_logging = !_cups_strncasecmp(value, "debug", 5); } else if (!_cups_strcasecmp(line, "<Policy") && !_cups_strcasecmp(value, "default")) { in_policy = 1; } else if (!_cups_strcasecmp(line, "</Policy>")) { in_policy = 0; } else if (!_cups_strcasecmp(line, "<Limit") && in_policy && value) { /* * See if the policy limit is for the Cancel-Job operation... */ char *valptr; /* Pointer into value */ while (*value) { for (valptr = value; *valptr && !_cups_isspace(*valptr); valptr ++); if (*valptr) *valptr++ = '\0'; if (!_cups_strcasecmp(value, "cancel-job") || !_cups_strcasecmp(value, "all")) { in_cancel_job = 1; break; } for (value = valptr; _cups_isspace(*value); value ++); } } else if (!_cups_strcasecmp(line, "</Limit>")) { in_cancel_job = 0; } else if (!_cups_strcasecmp(line, "Require") && in_cancel_job) { cancel_policy = 0; } else if (!_cups_strcasecmp(line, "<Location") && value) { in_admin_location = !_cups_strcasecmp(value, "/admin"); in_location = 1; } else if (!_cups_strcasecmp(line, "</Location>")) { in_admin_location = 0; in_location = 0; } else if (!_cups_strcasecmp(line, "Allow") && value && _cups_strcasecmp(value, "localhost") && _cups_strcasecmp(value, "127.0.0.1") #ifdef AF_LOCAL && *value != '/' #endif /* AF_LOCAL */ #ifdef AF_INET6 && strcmp(value, "::1") #endif /* AF_INET6 */ ) { if (in_admin_location) remote_admin = 1; else if (!_cups_strcasecmp(value, "all")) remote_any = 1; } else if (line[0] != '<' && !in_location && !in_policy && _cups_strcasecmp(line, "Allow") && _cups_strcasecmp(line, "AuthType") && _cups_strcasecmp(line, "Deny") && _cups_strcasecmp(line, "Order") && _cups_strcasecmp(line, "Require") && _cups_strcasecmp(line, "Satisfy")) cg->cupsd_num_settings = cupsAddOption(line, value, cg->cupsd_num_settings, &(cg->cupsd_settings)); } cupsFileClose(cupsd); cg->cupsd_num_settings = cupsAddOption(CUPS_SERVER_DEBUG_LOGGING, debug_logging ? "1" : "0", cg->cupsd_num_settings, &(cg->cupsd_settings)); cg->cupsd_num_settings = cupsAddOption(CUPS_SERVER_REMOTE_ADMIN, (remote_access && remote_admin) ? "1" : "0", cg->cupsd_num_settings, &(cg->cupsd_settings)); cg->cupsd_num_settings = cupsAddOption(CUPS_SERVER_REMOTE_ANY, remote_any ? "1" : "0", cg->cupsd_num_settings, &(cg->cupsd_settings)); cg->cupsd_num_settings = cupsAddOption(CUPS_SERVER_SHARE_PRINTERS, (remote_access && browsing) ? "1" : "0", cg->cupsd_num_settings, &(cg->cupsd_settings)); cg->cupsd_num_settings = cupsAddOption(CUPS_SERVER_USER_CANCEL_ANY, cancel_policy ? "1" : "0", cg->cupsd_num_settings, &(cg->cupsd_settings)); } else if (status != HTTP_STATUS_NOT_MODIFIED) invalidate_cupsd_cache(cg); /* * Remove any temporary files and copy the settings array... */ if (remote) unlink(cupsdconf); for (i = cg->cupsd_num_settings, setting = cg->cupsd_settings; i > 0; i --, setting ++) *num_settings = cupsAddOption(setting->name, setting->value, *num_settings, settings); return (cg->cupsd_num_settings > 0); }
int main(int argc, /* I - Number of command-line arguments */ char *argv[]) /* I - Command-line arguments */ { int i; /* Looping var */ http_t *http; /* Connection to server */ char *printer, /* Destination printer */ *pclass, /* Printer class name */ *val; /* Pointer to allow/deny value */ int num_options; /* Number of options */ cups_option_t *options; /* Options */ char *file; /* New PPD file/interface script */ _cupsSetLocale(argv); http = NULL; printer = NULL; num_options = 0; options = NULL; file = NULL; for (i = 1; i < argc; i ++) if (argv[i][0] == '-') switch (argv[i][1]) { case 'c' : /* Add printer to class */ if (!http) { http = httpConnectEncrypt(cupsServer(), ippPort(), cupsEncryption()); if (http == NULL) { _cupsLangPrintf(stderr, _("lpadmin: Unable to connect to server: %s"), strerror(errno)); return (1); } } if (printer == NULL) { _cupsLangPuts(stderr, _("lpadmin: Unable to add a printer to the class:\n" " You must specify a printer name " "first.")); return (1); } if (argv[i][2]) pclass = argv[i] + 2; else { i ++; if (i >= argc) { _cupsLangPuts(stderr, _("lpadmin: Expected class name after \"-c\" " "option.")); return (1); } pclass = argv[i]; } if (!validate_name(pclass)) { _cupsLangPuts(stderr, _("lpadmin: Class name can only contain printable " "characters.")); return (1); } if (add_printer_to_class(http, printer, pclass)) return (1); break; case 'd' : /* Set as default destination */ if (!http) { http = httpConnectEncrypt(cupsServer(), ippPort(), cupsEncryption()); if (http == NULL) { _cupsLangPrintf(stderr, _("lpadmin: Unable to connect to server: %s"), strerror(errno)); return (1); } } if (argv[i][2]) printer = argv[i] + 2; else { i ++; if (i >= argc) { _cupsLangPuts(stderr, _("lpadmin: Expected printer name after \"-d\" " "option.")); return (1); } printer = argv[i]; } if (!validate_name(printer)) { _cupsLangPuts(stderr, _("lpadmin: Printer name can only contain " "printable characters.")); return (1); } if (default_printer(http, printer)) return (1); i = argc; break; case 'h' : /* Connect to host */ if (http) { httpClose(http); http = NULL; } if (argv[i][2] != '\0') cupsSetServer(argv[i] + 2); else { i ++; if (i >= argc) { _cupsLangPuts(stderr, _("lpadmin: Expected hostname after \"-h\" " "option.")); return (1); } cupsSetServer(argv[i]); } break; case 'i' : /* Use the specified interface script */ if (argv[i][2]) file = argv[i] + 2; else { i ++; if (i >= argc) { _cupsLangPuts(stderr, _("lpadmin: Expected interface after \"-i\" " "option.")); return (1); } file = argv[i]; } break; case 'E' : /* Enable the printer */ if (printer == NULL) { #ifdef HAVE_SSL cupsSetEncryption(HTTP_ENCRYPT_REQUIRED); if (http) httpEncryption(http, HTTP_ENCRYPT_REQUIRED); #else _cupsLangPrintf(stderr, _("%s: Sorry, no encryption support."), argv[0]); #endif /* HAVE_SSL */ break; } if (!http) { http = httpConnectEncrypt(cupsServer(), ippPort(), cupsEncryption()); if (http == NULL) { _cupsLangPrintf(stderr, _("lpadmin: Unable to connect to server: %s"), strerror(errno)); return (1); } } if (enable_printer(http, printer)) return (1); break; case 'm' : /* Use the specified standard script/PPD file */ if (argv[i][2]) num_options = cupsAddOption("ppd-name", argv[i] + 2, num_options, &options); else { i ++; if (i >= argc) { _cupsLangPuts(stderr, _("lpadmin: Expected model after \"-m\" " "option.")); return (1); } num_options = cupsAddOption("ppd-name", argv[i], num_options, &options); } break; case 'o' : /* Set option */ if (argv[i][2]) num_options = cupsParseOptions(argv[i] + 2, num_options, &options); else { i ++; if (i >= argc) { _cupsLangPuts(stderr, _("lpadmin: Expected name=value after \"-o\" " "option.")); return (1); } num_options = cupsParseOptions(argv[i], num_options, &options); } break; case 'p' : /* Add/modify a printer */ if (argv[i][2]) printer = argv[i] + 2; else { i ++; if (i >= argc) { _cupsLangPuts(stderr, _("lpadmin: Expected printer after \"-p\" " "option.")); return (1); } printer = argv[i]; } if (!validate_name(printer)) { _cupsLangPuts(stderr, _("lpadmin: Printer name can only contain " "printable characters.")); return (1); } break; case 'r' : /* Remove printer from class */ if (!http) { http = httpConnectEncrypt(cupsServer(), ippPort(), cupsEncryption()); if (http == NULL) { _cupsLangPrintf(stderr, _("lpadmin: Unable to connect to server: %s"), strerror(errno)); return (1); } } if (printer == NULL) { _cupsLangPuts(stderr, _("lpadmin: Unable to remove a printer from the " "class:\n" " You must specify a printer name " "first.")); return (1); } if (argv[i][2]) pclass = argv[i] + 2; else { i ++; if (i >= argc) { _cupsLangPuts(stderr, _("lpadmin: Expected class after \"-r\" " "option.")); return (1); } pclass = argv[i]; } if (!validate_name(pclass)) { _cupsLangPuts(stderr, _("lpadmin: Class name can only contain printable " "characters.")); return (1); } if (delete_printer_from_class(http, printer, pclass)) return (1); break; case 'R' : /* Remove option */ if (!http) { http = httpConnectEncrypt(cupsServer(), ippPort(), cupsEncryption()); if (http == NULL) { _cupsLangPrintf(stderr, _("lpadmin: Unable to connect to server: %s"), strerror(errno)); return (1); } } if (printer == NULL) { _cupsLangPuts(stderr, _("lpadmin: Unable to delete option:\n" " You must specify a printer name " "first.")); return (1); } if (argv[i][2]) val = argv[i] + 2; else { i ++; if (i >= argc) { _cupsLangPuts(stderr, _("lpadmin: Expected name after \"-R\" " "option.")); return (1); } val = argv[i]; } if (delete_printer_option(http, printer, val)) return (1); break; case 'U' : /* Username */ if (argv[i][2] != '\0') cupsSetUser(argv[i] + 2); else { i ++; if (i >= argc) { _cupsLangPrintf(stderr, _("%s: Error - expected username after " "\"-U\" option."), argv[0]); return (1); } cupsSetUser(argv[i]); } break; case 'u' : /* Allow/deny users */ if (argv[i][2]) val = argv[i] + 2; else { i ++; if (i >= argc) { _cupsLangPuts(stderr, _("lpadmin: Expected allow/deny:userlist after " "\"-u\" option.")); return (1); } val = argv[i]; } if (!_cups_strncasecmp(val, "allow:", 6)) num_options = cupsAddOption("requesting-user-name-allowed", val + 6, num_options, &options); else if (!_cups_strncasecmp(val, "deny:", 5)) num_options = cupsAddOption("requesting-user-name-denied", val + 5, num_options, &options); else { _cupsLangPrintf(stderr, _("lpadmin: Unknown allow/deny option \"%s\"."), val); return (1); } break; case 'v' : /* Set the device-uri attribute */ if (argv[i][2]) num_options = cupsAddOption("device-uri", argv[i] + 2, num_options, &options); else { i ++; if (i >= argc) { _cupsLangPuts(stderr, _("lpadmin: Expected device URI after \"-v\" " "option.")); return (1); } num_options = cupsAddOption("device-uri", argv[i], num_options, &options); } break; case 'x' : /* Delete a printer */ if (!http) { http = httpConnectEncrypt(cupsServer(), ippPort(), cupsEncryption()); if (http == NULL) { _cupsLangPrintf(stderr, _("lpadmin: Unable to connect to server: %s"), strerror(errno)); return (1); } } if (argv[i][2]) printer = argv[i] + 2; else { i ++; if (i >= argc) { _cupsLangPuts(stderr, _("lpadmin: Expected printer or class after " "\"-x\" option.")); return (1); } printer = argv[i]; } if (!validate_name(printer)) { _cupsLangPuts(stderr, _("lpadmin: Printer name can only contain " "printable characters.")); return (1); } if (delete_printer(http, printer)) return (1); i = argc; break; case 'D' : /* Set the printer-info attribute */ if (argv[i][2]) num_options = cupsAddOption("printer-info", argv[i] + 2, num_options, &options); else { i ++; if (i >= argc) { _cupsLangPuts(stderr, _("lpadmin: Expected description after " "\"-D\" option.")); return (1); } num_options = cupsAddOption("printer-info", argv[i], num_options, &options); } break; case 'I' : /* Set the supported file types (ignored) */ i ++; if (i >= argc) { _cupsLangPuts(stderr, _("lpadmin: Expected file type(s) after \"-I\" " "option.")); return (1); } _cupsLangPuts(stderr, _("lpadmin: Warning - content type list ignored.")); break; case 'L' : /* Set the printer-location attribute */ if (argv[i][2]) num_options = cupsAddOption("printer-location", argv[i] + 2, num_options, &options); else { i ++; if (i >= argc) { _cupsLangPuts(stderr, _("lpadmin: Expected location after \"-L\" " "option.")); return (1); } num_options = cupsAddOption("printer-location", argv[i], num_options, &options); } break; case 'P' : /* Use the specified PPD file */ if (argv[i][2]) file = argv[i] + 2; else { i ++; if (i >= argc) { _cupsLangPuts(stderr, _("lpadmin: Expected PPD after \"-P\" option.")); return (1); } file = argv[i]; } break; default : _cupsLangPrintf(stderr, _("lpadmin: Unknown option \"%c\"."), argv[i][1]); return (1); } else { _cupsLangPrintf(stderr, _("lpadmin: Unknown argument \"%s\"."), argv[i]); return (1); } /* * Set options as needed... */ if (num_options || file) { if (!http) { http = httpConnectEncrypt(cupsServer(), ippPort(), cupsEncryption()); if (http == NULL) { _cupsLangPrintf(stderr, _("lpadmin: Unable to connect to server: %s"), strerror(errno)); return (1); } } if (printer == NULL) { _cupsLangPuts(stderr, _("lpadmin: Unable to set the printer options:\n" " You must specify a printer name first.")); return (1); } if (set_printer_options(http, printer, num_options, options, file)) return (1); } if (printer == NULL) { _cupsLangPuts(stdout, _("Usage:\n" "\n" " lpadmin [-h server] -d destination\n" " lpadmin [-h server] -x destination\n" " lpadmin [-h server] -p printer [-c add-class] " "[-i interface] [-m model]\n" " [-r remove-class] [-v device] " "[-D description]\n" " [-P ppd-file] [-o name=value]\n" " [-u allow:user,user] " "[-u deny:user,user]")); } if (http) httpClose(http); return (0); }
int DeviceAttributes_ ( ppd_file_t * ppd, oyOptions_s * options, oyConfig_s * device, const char * ppd_file_location ) { oyOption_s * o = 0; int error = !device; oyOption_s * value3 = oyOptions_Find( options, "device_context", oyNAME_PATTERN ); const char * device_name = oyConfig_FindString( device, "device_name", 0 ); if(!error) { char * manufacturer= 0, * model=0, * serial=0, * device_settings = 0; const char * system_port = 0, * host = 0; const char * keyword = 0; ppd_attr_t * attrs = 0; int attr_n, i, j; char ** color_key_words = 0, * tmp = 0; int color_key_words_n = 0; if(!device_name && !value3 && !ppd_file_location && !ppd) { message(oyMSG_WARN, (oyStruct_s*)options, _DBG_FORMAT_ "The \"device_name\" and \"device_context\" is\n" " missed to select a appropriate device.", _DBG_ARGS_ ); error = 1; return error; } if(!ppd) { message( oyMSG_DBG, (oyStruct_s*)0, _DBG_FORMAT_ "\n" "No PPD obtained for ", _DBG_ARGS_, device_name ); error = -1; return error; } manufacturer = ppd->manufacturer; model = ppd->modelname; serial = 0; /* Not known at this time. */ system_port = device_name; host = cupsServer(); attrs = ppdFindAttr(ppd, "cupsICCProfile", 0); if(attrs && attrs->text) device_settings = attrs->text; if(error <= 0) { size_t size = 0; char * data = 0; oyConfig_s * d = device; oyRankMap * rank_map = oyRankMapCopy( oyConfig_GetRankMap( device ), oyAllocateFunc_ ); if(!rank_map) rank_map = oyRankMapCopy( _api8.rank_map, oyAllocateFunc_ ); OPTIONS_ADD( oyConfig_GetOptions(d,"backend_core"), manufacturer ) OPTIONS_ADD( oyConfig_GetOptions(d,"backend_core"), model ) OPTIONS_ADD( oyConfig_GetOptions(d,"backend_core"), serial ) OPTIONS_ADD( oyConfig_GetOptions(d,"backend_core"), system_port ) OPTIONS_ADD( oyConfig_GetOptions(d,"backend_core"), host ) OPTIONS_ADD( oyConfig_GetOptions(d,"backend_core"), device_settings ) if (value3) { /* open the PPD data */ if(ppd_file_location) { FILE * fp = fopen( ppd_file_location, "r" ); size_t lsize = 0; /* Find the total size. */ fseek(fp , 0, SEEK_END); lsize = ftell(fp); rewind (fp); /* Create buffer to read contents into a profile. */ data = (char*) malloc (sizeof(char)*lsize + 1); if (data == NULL) fputs ("Unable to open PPD size.",stderr); size = fread( data, 1, lsize, fp); data[size] = 0; } if(!error && data && size) { o = oyOption_FromRegistration( CMM_BASE_REG OY_SLASH "device_context.PPD.text", 0 ); error = !o; if(!error) error = oyOption_SetFromData( o, data, size ); if(!error) oyOptions_MoveIn( *oyConfig_GetOptions(device,"data"), &o, -1 ); } } /* Collect all ColorKeyWords. */ attr_n = ppd->num_attrs; for(i = 0; i < attr_n; i++) { char key[16]; keyword = ppd->attrs[i]->name; /* we support keys beginning with ColorKeyWords, e.g. "ColorKeyWords" "ColorKeyWords" ... */ snprintf( &key[0], 16, "%s", keyword ); key[14] = 0; if (strcmp(key, "ColorKeyWords") == 0) { if( tmp && tmp[oyStrlen_(tmp) - 1] != ';' ) STRING_ADD( tmp, ";" ); STRING_ADD( tmp, ppd->attrs[i]->value ); } } if(tmp) { color_key_words = oyStringSplit( tmp, ';', &color_key_words_n, oyAllocateFunc_); oyDeAllocateFunc_( tmp ); tmp = 0; } /* add the key/value pairs to the devices backend_core options. */ for(j = 0; j < color_key_words_n; ++j) { const char * keyword = color_key_words[j], * value = NULL; ppd_choice_t * c = ppdFindMarkedChoice( ppd, keyword ); ppd_option_t * o = ppdFindOption( ppd, keyword ); char * reg_name = 0; /* take the marked choice */ if(c) value = c->choice; /* fall back to a default */ else if(o) value = o->defchoice; else /* Scan PPD attributes for matching the ColorKeyWords and */ for(i = 0; i < attr_n; i++) if(oyStrcmp_( ppd->attrs[i]->name, keyword ) == 0) value = ppd->attrs[i]->value; STRING_ADD( reg_name, CMM_BASE_REG OY_SLASH ); STRING_ADD( reg_name, keyword ); if(value) { error= oyOptions_SetFromText( oyConfig_GetOptions(d,"backend_core"), reg_name, value, OY_CREATE_NEW ); oyRankMapAppend( &rank_map, reg_name, 2, -2, 0, 0,0 ); } if(reg_name) oyDeAllocateFunc_( reg_name ); reg_name = 0; } if( color_key_words && color_key_words_n) oyStringListRelease_( &color_key_words, color_key_words_n, oyDeAllocateFunc_ ); else { ppd_option_t * o; while((o = ppdNextOption(ppd)) != 0) { const char * value = 0; char * reg_name = 0; keyword = o->keyword; STRING_ADD( reg_name, CMM_BASE_REG OY_SLASH ); STRING_ADD( reg_name, keyword ); /* take the marked choice */ for(i = 0; i < o->num_choices; ++i) if(o->choices[i].marked) { value = o->choices[i].choice; break; } if(!value) value = o->defchoice; if(value) { error = oyOptions_SetFromText( oyConfig_GetOptions(d,"backend_core"), reg_name, value, OY_CREATE_NEW ); oyRankMapAppend( &rank_map, reg_name, 2, -2, 0, 0,0 ); } if(reg_name) oyDeAllocateFunc_( reg_name ); reg_name = 0; } } oyConfig_SetRankMap( device, rank_map ); oyRankMapRelease( &rank_map, oyDeAllocateFunc_ ); }
static char * /* I - Printer name or NULL */ cups_connect(const char *name, /* I - Destination (printer[@host]) */ char *printer, /* O - Printer name [HTTP_MAX_URI] */ char *hostname) /* O - Hostname [HTTP_MAX_URI] */ { char hostbuf[HTTP_MAX_URI], /* Name of host */ http_hostname[HTTP_MAX_HOST]; /* Hostname associated with connection */ _cups_globals_t *cg = _cupsGlobals();/* Pointer to library globals */ DEBUG_printf(("cups_connect(\"%s\", %p, %p)\n", name, printer, hostname)); if (name == NULL) { _cupsSetError(IPP_BAD_REQUEST, NULL); return (NULL); } /* * All jobs are now queued to cupsServer() to avoid hostname * resolution problems and to ensure that the user sees all * locally queued jobs locally. */ strlcpy(hostbuf, cupsServer(), sizeof(hostbuf)); httpGetHostname(cg->http, http_hostname, sizeof(http_hostname)); if (hostname != NULL) strlcpy(hostname, hostbuf, HTTP_MAX_URI); else hostname = hostbuf; if (printer != NULL) strlcpy(printer, name, HTTP_MAX_URI); else printer = (char *)name; if (cg->http != NULL) { if (!strcasecmp(http_hostname, hostname)) return (printer); httpClose(cg->http); } DEBUG_printf(("connecting to %s on port %d...\n", hostname, ippPort())); if ((cg->http = httpConnectEncrypt(hostname, ippPort(), cupsEncryption())) == NULL) { DEBUG_puts("Unable to connect to server!"); _cupsSetError(IPP_SERVICE_UNAVAILABLE, strerror(errno)); return (NULL); } else return (printer); }
bool CupsdConf::loadAvailableResources() { KConfig conf("kdeprintrc"); conf.setGroup("CUPS"); QString host = conf.readEntry("Host", cupsServer()); int port = conf.readNumEntry("Port", ippPort()); http_t *http_ = httpConnect(host.local8Bit(), port); resources_.clear(); // standard resources resources_.append(new CupsResource("/")); resources_.append(new CupsResource("/admin")); resources_.append(new CupsResource("/printers")); resources_.append(new CupsResource("/classes")); resources_.append(new CupsResource("/jobs")); if(!http_) return false; // printer resources ipp_t *request_ = ippNew(); cups_lang_t *lang = cupsLangDefault(); ippAddString(request_, IPP_TAG_OPERATION, IPP_TAG_CHARSET, "attributes-charset", NULL, cupsLangEncoding(lang)); ippAddString(request_, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE, "attributes-natural-language", NULL, lang->language); request_->request.op.operation_id = CUPS_GET_PRINTERS; request_ = cupsDoRequest(http_, request_, "/printers/"); if(request_) { QString name; int type(0); ipp_attribute_t *attr = request_->attrs; while(attr) { // check new printer (keep only local non-implicit printers) if(!attr->name) { if(!(type & CUPS_PRINTER_REMOTE) && !(type & CUPS_PRINTER_IMPLICIT) && !name.isEmpty()) resources_.append(new CupsResource("/printers/" + name)); name = ""; type = 0; } else if(strcmp(attr->name, "printer-name") == 0) name = attr->values[0].string.text; else if(strcmp(attr->name, "printer-type") == 0) type = attr->values[0].integer; attr = attr->next; } if(!(type & CUPS_PRINTER_REMOTE) && !(type & CUPS_PRINTER_IMPLICIT) && !name.isEmpty()) resources_.append(new CupsResource("/printers/" + name)); ippDelete(request_); } // class resources request_ = ippNew(); ippAddString(request_, IPP_TAG_OPERATION, IPP_TAG_CHARSET, "attributes-charset", NULL, cupsLangEncoding(lang)); ippAddString(request_, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE, "attributes-natural-language", NULL, lang->language); request_->request.op.operation_id = CUPS_GET_CLASSES; request_ = cupsDoRequest(http_, request_, "/classes/"); if(request_) { QString name; int type(0); ipp_attribute_t *attr = request_->attrs; while(attr) { // check new class (keep only local classes) if(!attr->name) { if(!(type & CUPS_PRINTER_REMOTE) && !name.isEmpty()) resources_.append(new CupsResource("/classes/" + name)); name = ""; type = 0; } else if(strcmp(attr->name, "printer-name") == 0) name = attr->values[0].string.text; else if(strcmp(attr->name, "printer-type") == 0) type = attr->values[0].integer; attr = attr->next; } if(!(type & CUPS_PRINTER_REMOTE) && !name.isEmpty()) resources_.append(new CupsResource("/classes/" + name)); ippDelete(request_); } httpClose(http_); return true; }
GtkCupsRequest * gtk_cups_request_new_with_username (http_t *connection, GtkCupsRequestType req_type, gint operation_id, GIOChannel *data_io, const char *server, const char *resource, const char *username) { GtkCupsRequest *request; cups_lang_t *language; request = g_new0 (GtkCupsRequest, 1); request->result = g_new0 (GtkCupsResult, 1); request->result->error_msg = NULL; request->result->ipp_response = NULL; request->result->is_error = FALSE; request->result->is_ipp_response = FALSE; request->type = req_type; request->state = GTK_CUPS_REQUEST_START; request->password_state = GTK_CUPS_PASSWORD_NONE; if (server) request->server = g_strdup (server); else request->server = g_strdup (cupsServer ()); if (resource) request->resource = g_strdup (resource); else request->resource = g_strdup ("/"); if (connection != NULL) { request->http = connection; request->own_http = FALSE; } else { request->http = NULL; request->http = httpConnectEncrypt (request->server, ippPort (), cupsEncryption ()); if (request->http) httpBlocking (request->http, 0); request->own_http = TRUE; } request->last_status = HTTP_CONTINUE; request->attempts = 0; request->data_io = data_io; request->ipp_request = ippNew (); ippSetOperation (request->ipp_request, operation_id); ippSetRequestId (request->ipp_request, 1); language = cupsLangDefault (); gtk_cups_request_ipp_add_string (request, IPP_TAG_OPERATION, IPP_TAG_CHARSET, "attributes-charset", NULL, "utf-8"); gtk_cups_request_ipp_add_string (request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE, "attributes-natural-language", NULL, language->language); if (username != NULL) gtk_cups_request_ipp_add_string (request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", NULL, username); else gtk_cups_request_ipp_add_string (request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", NULL, cupsUser ()); request->auth_info_required = NULL; request->auth_info = NULL; request->need_auth_info = FALSE; cupsLangFree (language); return request; }
int /* O - Exit status */ main(void) { http_t *http; /* Connection to the server */ const char *op; /* Operation name */ const char *job_id_var; /* Job ID form variable */ int job_id; /* Job ID */ /* * Get any form variables... */ cgiInitialize(); /* * Set the web interface section... */ cgiSetVariable("SECTION", "jobs"); cgiSetVariable("REFRESH_PAGE", ""); /* * Connect to the HTTP server... */ http = httpConnectEncrypt(cupsServer(), ippPort(), cupsEncryption()); /* * Get the job ID, if any... */ if ((job_id_var = cgiGetVariable("JOB_ID")) != NULL) job_id = atoi(job_id_var); else job_id = 0; /* * Do the operation... */ if ((op = cgiGetVariable("OP")) != NULL && job_id > 0 && cgiIsPOST()) { /* * Do the operation... */ if (!strcmp(op, "cancel-job")) do_job_op(http, job_id, IPP_CANCEL_JOB); else if (!strcmp(op, "hold-job")) do_job_op(http, job_id, IPP_HOLD_JOB); else if (!strcmp(op, "move-job")) cgiMoveJobs(http, NULL, job_id); else if (!strcmp(op, "release-job")) do_job_op(http, job_id, IPP_RELEASE_JOB); else if (!strcmp(op, "restart-job")) do_job_op(http, job_id, IPP_RESTART_JOB); else { /* * Bad operation code... Display an error... */ cgiStartHTML(cgiText(_("Jobs"))); cgiCopyTemplateLang("error-op.tmpl"); cgiEndHTML(); } } else { /* * Show a list of jobs... */ cgiStartHTML(cgiText(_("Jobs"))); cgiShowJobs(http, NULL); cgiEndHTML(); } /* * Close the HTTP server connection... */ httpClose(http); /* * Return with no errors... */ return (0); }
int main(int argc, /* I - Number of command-line arguments */ char *argv[]) /* I - Command-line arguments */ { int i; /* Looping var */ const char *server; /* Server to use */ http_encryption_t encryption; /* Encryption to use */ int requests; /* Number of requests to send */ int children; /* Number of children to fork */ int pid; /* Child PID */ int status; /* Child status */ time_t start, /* Start time */ end; /* End time */ double elapsed; /* Elapsed time */ int verbose; /* Verbosity */ /* * Parse command-line options... */ requests = 100; children = 5; server = cupsServer(); encryption = HTTP_ENCRYPT_IF_REQUESTED; verbose = 0; for (i = 1; i < argc; i ++) if (!strcmp(argv[i], "-c")) { i ++; if (i >= argc) usage(); children = atoi(argv[i]); } else if (!strcmp(argv[i], "-r")) { i ++; if (i >= argc) usage(); requests = atoi(argv[i]); } else if (!strcmp(argv[i], "-E")) encryption = HTTP_ENCRYPT_REQUIRED; else if (!strcmp(argv[i], "-v")) verbose ++; else if (argv[i][0] == '-') usage(); else server = argv[i]; /* * Then create child processes to act as clients... */ printf("testspeed: Simulating %d clients with %d requests to %s with %s encryption...\n", children, requests, server, encryption == HTTP_ENCRYPT_IF_REQUESTED ? "no" : ""); start = time(NULL); if (children == 1) { do_test(server, encryption, requests, verbose); } else { for (i = 0; i < children; i ++) if ((pid = fork()) == 0) { /* * Child goes here... */ exit(do_test(server, encryption, requests, verbose)); } else if (pid < 0) { perror("fork failed"); break; } else printf("testspeed(%d): Started...\n", pid); /* * Wait for children to finish... */ for (;;) { pid = wait(&status); if (pid < 0 && errno != EINTR) break; printf("testspeed(%d): Ended (%d)...\n", pid, status); } } /* * Compute the total run time... */ end = time(NULL); elapsed = end - start; i = children * requests; printf("testspeed: %dx%d=%d requests in %.1fs (%.3fs/r, %.1fr/s)\n", children, requests, i, elapsed, elapsed / i, i / elapsed); /* * Exit with no errors... */ return (0); }
int main(int argc, /* I - Number of command-line arguments */ char *argv[]) /* I - Command-line arguments */ { int i; /* Looping var */ const char *uri; /* URI to use */ int num_events; /* Number of events */ const char *events[100]; /* Events */ int subscription_id, /* notify-subscription-id */ sequence_number, /* notify-sequence-number */ interval; /* Interval between polls */ http_t *http; /* HTTP connection */ ipp_t *request, /* IPP request */ *response; /* IPP response */ ipp_attribute_t *attr; /* Current attribute */ #if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET) struct sigaction action; /* Actions for POSIX signals */ #endif /* HAVE_SIGACTION && !HAVE_SIGSET */ /* * Parse command-line... */ num_events = 0; uri = NULL; for (i = 1; i < argc; i ++) if (!strcmp(argv[i], "-E")) cupsSetEncryption(HTTP_ENCRYPT_REQUIRED); else if (!strcmp(argv[i], "-e")) { i ++; if (i >= argc || num_events >= 100) usage(); events[num_events] = argv[i]; num_events ++; } else if (!strcmp(argv[i], "-h")) { i ++; if (i >= argc) usage(); cupsSetServer(argv[i]); } else if (uri || strncmp(argv[i], "ipp://", 6)) usage(); else uri = argv[i]; if (!uri) usage(); if (num_events == 0) { events[0] = "all"; num_events = 1; } /* * Connect to the server... */ if ((http = httpConnectEncrypt(cupsServer(), ippPort(), cupsEncryption())) == NULL) { perror(cupsServer()); return (1); } /* * Catch CTRL-C and SIGTERM... */ #ifdef HAVE_SIGSET /* Use System V signals over POSIX to avoid bugs */ sigset(SIGINT, sigterm_handler); sigset(SIGTERM, sigterm_handler); #elif defined(HAVE_SIGACTION) memset(&action, 0, sizeof(action)); sigemptyset(&action.sa_mask); action.sa_handler = sigterm_handler; sigaction(SIGINT, &action, NULL); sigaction(SIGTERM, &action, NULL); #else signal(SIGINT, sigterm_handler); signal(SIGTERM, sigterm_handler); #endif /* HAVE_SIGSET */ /* * Create the subscription... */ if (strstr(uri, "/jobs/")) { request = ippNewRequest(IPP_CREATE_JOB_SUBSCRIPTION); ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL, uri); } else { request = ippNewRequest(IPP_CREATE_PRINTER_SUBSCRIPTION); ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri); } ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", NULL, cupsUser()); ippAddStrings(request, IPP_TAG_SUBSCRIPTION, IPP_TAG_KEYWORD, "notify-events", num_events, NULL, events); ippAddString(request, IPP_TAG_SUBSCRIPTION, IPP_TAG_KEYWORD, "notify-pull-method", NULL, "ippget"); response = cupsDoRequest(http, request, uri); if (cupsLastError() >= IPP_BAD_REQUEST) { fprintf(stderr, "Create-%s-Subscription: %s\n", strstr(uri, "/jobs") ? "Job" : "Printer", cupsLastErrorString()); ippDelete(response); httpClose(http); return (1); } if ((attr = ippFindAttribute(response, "notify-subscription-id", IPP_TAG_INTEGER)) == NULL) { fputs("ERROR: No notify-subscription-id in response!\n", stderr); ippDelete(response); httpClose(http); return (1); } subscription_id = attr->values[0].integer; printf("Create-%s-Subscription: notify-subscription-id=%d\n", strstr(uri, "/jobs/") ? "Job" : "Printer", subscription_id); ippDelete(response); /* * Monitor for events... */ sequence_number = 0; while (!terminate) { /* * Get the current events... */ printf("\nGet-Notifications(%d,%d):", subscription_id, sequence_number); fflush(stdout); request = ippNewRequest(IPP_GET_NOTIFICATIONS); if (strstr(uri, "/jobs/")) ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL, uri); else ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri); ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", NULL, cupsUser()); ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "notify-subscription-ids", subscription_id); if (sequence_number) ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "notify-sequence-numbers", sequence_number + 1); response = cupsDoRequest(http, request, uri); printf(" %s\n", ippErrorString(cupsLastError())); if (cupsLastError() >= IPP_BAD_REQUEST) fprintf(stderr, "Get-Notifications: %s\n", cupsLastErrorString()); else if (response) { print_attributes(response, 0); for (attr = ippFindAttribute(response, "notify-sequence-number", IPP_TAG_INTEGER); attr; attr = ippFindNextAttribute(response, "notify-sequence-number", IPP_TAG_INTEGER)) if (attr->values[0].integer > sequence_number) sequence_number = attr->values[0].integer; } if ((attr = ippFindAttribute(response, "notify-get-interval", IPP_TAG_INTEGER)) != NULL && attr->values[0].integer > 0) interval = attr->values[0].integer; else interval = 5; ippDelete(response); sleep(interval); } /* * Cancel the subscription... */ printf("\nCancel-Subscription:"); fflush(stdout); request = ippNewRequest(IPP_CANCEL_SUBSCRIPTION); if (strstr(uri, "/jobs/")) ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL, uri); else ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri); ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", NULL, cupsUser()); ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "notify-subscription-id", subscription_id); ippDelete(cupsDoRequest(http, request, uri)); printf(" %s\n", ippErrorString(cupsLastError())); if (cupsLastError() >= IPP_BAD_REQUEST) fprintf(stderr, "Cancel-Subscription: %s\n", cupsLastErrorString()); /* * Close the connection and return... */ httpClose(http); return (0); }