char * /* O - Name of PPD file or @code NULL@ on error */
cupsGetServerPPD(http_t *http, /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
const char *name) /* I - Name of PPD file ("ppd-name") */
{
int fd; /* PPD file descriptor */
ipp_t *request; /* IPP request */
_cups_globals_t *cg = _cupsGlobals();
/* Pointer to library globals */
/*
* Range check input...
*/
if (!name)
{
_cupsSetError(IPP_INTERNAL_ERROR, _("No PPD name"), 1);
return (NULL);
}
if (!http)
if ((http = _cupsConnect()) == NULL)
return (NULL);
/*
* Get a temp file...
*/
if ((fd = cupsTempFd(cg->ppd_filename, sizeof(cg->ppd_filename))) < 0)
{
/*
* Can't open file; close the server connection and return NULL...
*/
_cupsSetError(IPP_INTERNAL_ERROR, NULL, 0);
return (NULL);
}
/*
* Get the PPD file...
*/
request = ippNewRequest(CUPS_GET_PPD);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "ppd-name", NULL,
name);
ippDelete(cupsDoIORequest(http, request, "/", -1, fd));
close(fd);
if (cupsLastError() != IPP_OK)
{
unlink(cg->ppd_filename);
return (NULL);
}
else
return (cg->ppd_filename);
}
/* Cancels subscription of given id */
static void
cancel_subscription_thread (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
ipp_t *request;
ipp_t *response = NULL;
gint id = GPOINTER_TO_INT (task_data);
if (id >= 0)
{
request = ippNewRequest (IPP_CANCEL_SUBSCRIPTION);
ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_URI,
"printer-uri", NULL, "/");
ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_NAME,
"requesting-user-name", NULL, cupsUser ());
ippAddInteger (request, IPP_TAG_OPERATION, IPP_TAG_INTEGER,
"notify-subscription-id", id);
response = cupsDoRequest (CUPS_HTTP_DEFAULT, request, "/");
}
g_task_return_boolean (task, response != NULL && ippGetStatusCode (response) <= IPP_OK);
ippDelete (response);
}
///////////////////////////////////////////////////////////////////////////////////////////
//
// CS : PUBLIC gint getPrinterStatus(gchar *pDestName, gchar *pStatus, gint bufSize)
// IN : gchar *pDestName : Printer name.
// gint bufSize : Size of output buffer.
// OUT : gchar *pStatus : Printer status string.
// RETURN : ID_ERR_NO_ERROR : No error.
// ID_ERR_CUPS_API_FAILED : Error occured in CUPS API.
//
PUBLIC gint getPrinterStatus(gchar *pDestName, gchar *pStatus, 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 printerURI[HTTP_MAX_URI]; // Printer URI.
gchar serverName[HTTP_MAX_URI]; // CUPS server name.
gint retVal = ID_ERR_NO_ERROR; // Return value.
/*** Parameters end ***/
// Initialize buffer.
memset(printerURI, 0, sizeof(printerURI));
memset(serverName, 0, sizeof(serverName));
// Get printer URI and CUPS server name.
retVal = getPrinterURI(pDestName, printerURI, serverName, HTTP_MAX_URI);
if (retVal == ID_ERR_NO_ERROR) {
// CUPS http connect.
if ((pHTTP = httpConnectEncrypt(serverName, ippPort(), cupsEncryption())) == NULL) {
retVal = ID_ERR_CUPS_API_FAILED;
}
else {
pRequest = ippNew();
ippSetOperation(pRequest, IPP_GET_PRINTER_ATTRIBUTES);
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);
ippAddString(pRequest, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, printerURI);
if ((pResponse = cupsDoRequest(pHTTP, pRequest, "/")) != NULL) {
if (ippGetStatusCode(pResponse) > IPP_OK_CONFLICT) {
retVal = ID_ERR_CUPS_API_FAILED;
}
else {
pAttribute = ippFindAttribute(pResponse, "printer-state-message", IPP_TAG_TEXT);
if (pAttribute != NULL) {
strncpy(pStatus, ippGetString(pAttribute, 0, NULL), bufSize);
}
}
ippDelete(pResponse);
}
else {
retVal = ID_ERR_CUPS_API_FAILED;
}
cupsLangFree(pLanguage);
httpClose(pHTTP);
}
}
return(retVal);
}// End getPrinterStatus
static void
gtk_cups_result_free (GtkCupsResult *result)
{
g_free (result->error_msg);
if (result->ipp_response)
ippDelete (result->ipp_response);
g_free (result);
}
static void
cupsd_delete_event(cupsd_event_t *event)/* I - Event to delete */
{
/*
* Free memory...
*/
ippDelete(event->attrs);
free(event);
}
static cups_ptype_t /* O - printer-type value */
get_printer_type(http_t *http, /* I - Server connection */
char *printer, /* I - Printer name */
char *uri, /* I - URI buffer */
size_t urisize) /* I - Size of URI buffer */
{
ipp_t *request, /* IPP request */
*response; /* IPP response */
ipp_attribute_t *attr; /* printer-type attribute */
cups_ptype_t type; /* printer-type value */
/*
* Build a GET_PRINTER_ATTRIBUTES request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
* requested-attributes
* requesting-user-name
*/
httpAssembleURIf(HTTP_URI_CODING_ALL, uri, urisize, "ipp", NULL, "localhost",
ippPort(), "/printers/%s", printer);
request = ippNewRequest(IPP_GET_PRINTER_ATTRIBUTES);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
"printer-uri", NULL, uri);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
"requested-attributes", NULL, "printer-type");
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
"requesting-user-name", NULL, cupsUser());
/*
* Do the request...
*/
response = cupsDoRequest(http, request, "/");
if ((attr = ippFindAttribute(response, "printer-type",
IPP_TAG_ENUM)) != NULL)
{
type = (cups_ptype_t)attr->values[0].integer;
if (type & CUPS_PRINTER_CLASS)
httpAssembleURIf(HTTP_URI_CODING_ALL, uri, urisize, "ipp", NULL,
"localhost", ippPort(), "/classes/%s", printer);
}
else
type = CUPS_PRINTER_LOCAL;
ippDelete(response);
return (type);
}
///////////////////////////////////////////////////////////////////////////////////////////
//
// CS : PRIVATE gint checkPrinterState(gchar *pDestName, gchar *pURI, gchar *pServerName)
// IN : gchar *pDestName : Printer name.
// gchar *pURI : Printer URI.
// gchar *pServerName : CUPS server name.
// OUT : None.
// RETURN : ID_ERR_NO_ERROR : No error.
// ID_ERR_UNKNOWN_PRINTER : No printer registerd in CUPS.
// ID_ERR_CUPS_API_FAILED : Error occured in CUPS API.
//
PRIVATE gint checkPrinterState(gchar *pDestName, gchar *pURI, gchar *pServerName)
{
/*** 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.
ipp_pstate_t printerState = IPP_PRINTER_STOPPED; // Pointer to printer state.
gint retVal = ID_ERR_UNKNOWN_PRINTER; // Return value.
/*** Parameters end ***/
// CUPS http connect.
if ((pHTTP = httpConnectEncrypt(pServerName, ippPort(), cupsEncryption())) == NULL) {
retVal = ID_ERR_CUPS_API_FAILED;
}
else {
pRequest = ippNew();
ippSetOperation(pRequest, IPP_GET_PRINTER_ATTRIBUTES);
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);
ippAddString(pRequest, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, pURI);
if ((pResponse = cupsDoRequest(pHTTP, pRequest, "/")) != NULL) {
if (ippGetStatusCode(pResponse) > IPP_OK_CONFLICT) {
retVal = ID_ERR_CUPS_API_FAILED;
}
else {
if ((pAttribute = ippFindAttribute(pResponse, "printer-state", IPP_TAG_ENUM)) != NULL) {
printerState = (ipp_state_t) ippGetInteger(pAttribute, 0);
}
}
ippDelete(pResponse);
}
else {
retVal = ID_ERR_CUPS_API_FAILED;
}
cupsLangFree(pLanguage);
httpClose(pHTTP);
}
if (printerState == IPP_PRINTER_IDLE || printerState == IPP_PRINTER_PROCESSING) {
retVal = ID_ERR_NO_ERROR;
}
return(retVal);
}// End checkPrinterState
static int /* O - 0 on success, -1 on failure */
print_file(http_t *http, /* I - HTTP connection */
int id, /* I - Job ID */
const char *filename, /* I - File to print */
const char *docname, /* I - document-name */
const char *user, /* I - requesting-user-name */
const char *format, /* I - document-format */
int last) /* I - 1 = last file in job */
{
ipp_t *request; /* IPP request */
char uri[HTTP_MAX_URI]; /* Printer URI */
/*
* Setup the Send-Document request...
*/
request = ippNewRequest(IPP_SEND_DOCUMENT);
snprintf(uri, sizeof(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, user);
if (docname)
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
"document-name", NULL, docname);
if (format)
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE,
"document-format", NULL, format);
ippAddBoolean(request, IPP_TAG_OPERATION, "last-document", (char)last);
/*
* Do the request...
*/
snprintf(uri, sizeof(uri), "/jobs/%d", id);
ippDelete(cupsDoFileRequest(http, request, uri, filename));
if (cupsLastError() > IPP_OK_CONFLICT)
{
syslog(LOG_ERR, "Unable to send document - %s", cupsLastErrorString());
return (-1);
}
return (0);
}
static int /* O - 1 on failure, 0 on success */
test_pagesize(_ppd_cache_t *pc, /* I - PWG mapping data */
ppd_file_t *ppd, /* I - PPD file */
const char *ppdsize) /* I - PPD page size */
{
int status = 0; /* Return status */
ipp_t *job; /* Job attributes */
const char *pagesize; /* PageSize value */
if (ppdPageSize(ppd, ppdsize))
{
printf("_ppdCacheGetPageSize(keyword=%s): ", ppdsize);
fflush(stdout);
if ((pagesize = _ppdCacheGetPageSize(pc, NULL, ppdsize, NULL)) == NULL)
{
puts("FAIL (Not Found)");
status = 1;
}
else if (_cups_strcasecmp(pagesize, ppdsize))
{
printf("FAIL (Got \"%s\", Expected \"%s\")\n", pagesize, ppdsize);
status = 1;
}
else
puts("PASS");
job = ippNew();
ippAddString(job, IPP_TAG_JOB, IPP_TAG_KEYWORD, "media", NULL, ppdsize);
printf("_ppdCacheGetPageSize(media=%s): ", ppdsize);
fflush(stdout);
if ((pagesize = _ppdCacheGetPageSize(pc, job, NULL, NULL)) == NULL)
{
puts("FAIL (Not Found)");
status = 1;
}
else if (_cups_strcasecmp(pagesize, ppdsize))
{
printf("FAIL (Got \"%s\", Expected \"%s\")\n", pagesize, ppdsize);
status = 1;
}
else
puts("PASS");
ippDelete(job);
}
return (status);
}
http_status_t /* O - HTTP status of request */
cupsStartDocument(
http_t *http, /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
const char *name, /* I - Destination name */
int job_id, /* I - Job ID from @link cupsCreateJob@ */
const char *docname, /* I - Name of document */
const char *format, /* I - MIME type or @code CUPS_FORMAT_foo@ */
int last_document) /* I - 1 for last document in job, 0 otherwise */
{
char resource[1024], /* Resource for destinatio */
printer_uri[1024]; /* Printer URI */
ipp_t *request; /* Send-Document request */
http_status_t status; /* HTTP status */
/*
* Create a Send-Document request...
*/
if ((request = ippNewRequest(IPP_SEND_DOCUMENT)) == NULL)
{
_cupsSetError(IPP_INTERNAL_ERROR, strerror(ENOMEM), 0);
return (HTTP_ERROR);
}
httpAssembleURIf(HTTP_URI_CODING_ALL, printer_uri, sizeof(printer_uri), "ipp",
NULL, "localhost", ippPort(), "/printers/%s", name);
snprintf(resource, sizeof(resource), "/printers/%s", name);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
NULL, printer_uri);
ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id", job_id);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
NULL, cupsUser());
if (docname)
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "document-name",
NULL, docname);
if (format)
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE,
"document-format", NULL, format);
ippAddBoolean(request, IPP_TAG_OPERATION, "last-document", last_document);
/*
* Send and delete the request, then return the status...
*/
status = cupsSendRequest(http, request, resource, CUPS_LENGTH_VARIABLE);
ippDelete(request);
return (status);
}
ipp_status_t /* O - Status of document submission */
cupsFinishDocument(http_t *http, /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
const char *name) /* I - Destination name */
{
char resource[1024]; /* Printer resource */
snprintf(resource, sizeof(resource), "/printers/%s", name);
ippDelete(cupsGetResponse(http, resource));
return (cupsLastError());
}
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;
}
static int /* O - 0 on success, 1 on fail */
enable_printer(http_t *http, /* I - Server connection */
char *printer) /* I - Printer to enable */
{
ipp_t *request; /* IPP Request */
char uri[HTTP_MAX_URI]; /* URI for printer/class */
DEBUG_printf(("enable_printer(%p, \"%s\")\n", http, printer));
/*
* Build a CUPS_ADD_MODIFY_PRINTER or CUPS_ADD_MODIFY_CLASS request, which
* require the following attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
* requesting-user-name
* printer-state
* printer-is-accepting-jobs
*/
if (get_printer_type(http, printer, uri, sizeof(uri)) & CUPS_PRINTER_CLASS)
request = ippNewRequest(CUPS_ADD_MODIFY_CLASS);
else
request = ippNewRequest(CUPS_ADD_MODIFY_PRINTER);
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_PRINTER, IPP_TAG_ENUM, "printer-state",
IPP_PRINTER_IDLE);
ippAddBoolean(request, IPP_TAG_PRINTER, "printer-is-accepting-jobs", 1);
/*
* Do the request and get back a response...
*/
ippDelete(cupsDoRequest(http, request, "/admin/"));
if (cupsLastError() > IPP_OK_CONFLICT)
{
_cupsLangPrintf(stderr, _("%s: %s"), "lpadmin", cupsLastErrorString());
return (1);
}
else
return (0);
}
static int /* O - 0 on success, 1 on fail */
delete_printer_option(http_t *http, /* I - Server connection */
char *printer, /* I - Printer */
char *option) /* I - Option to delete */
{
ipp_t *request; /* IPP request */
char uri[HTTP_MAX_URI]; /* URI for printer/class */
/*
* Build a CUPS_ADD_MODIFY_PRINTER or CUPS_ADD_MODIFY_CLASS request, which
* requires the following attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
* requesting-user-name
* option with deleteAttr tag
*/
if (get_printer_type(http, printer, uri, sizeof(uri)) & CUPS_PRINTER_CLASS)
request = ippNewRequest(CUPS_ADD_MODIFY_CLASS);
else
request = ippNewRequest(CUPS_ADD_MODIFY_PRINTER);
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_PRINTER, IPP_TAG_DELETEATTR, option, 0);
/*
* Do the request and get back a response...
*/
ippDelete(cupsDoRequest(http, request, "/admin/"));
if (cupsLastError() > IPP_OK_CONFLICT)
{
_cupsLangPrintf(stderr, _("%s: %s"), "lpadmin", cupsLastErrorString());
return (1);
}
else
return (0);
}
static int /* O - 0 on success, 1 on fail */
default_printer(http_t *http, /* I - Server connection */
char *printer) /* I - Printer name */
{
ipp_t *request; /* IPP Request */
char uri[HTTP_MAX_URI]; /* URI for printer/class */
DEBUG_printf(("default_printer(%p, \"%s\")\n", http, printer));
/*
* Build a CUPS_SET_DEFAULT request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
* requesting-user-name
*/
httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
"localhost", 0, "/printers/%s", printer);
request = ippNewRequest(CUPS_SET_DEFAULT);
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());
/*
* Do the request and get back a response...
*/
ippDelete(cupsDoRequest(http, request, "/admin/"));
if (cupsLastError() > IPP_OK_CONFLICT)
{
_cupsLangPrintf(stderr, _("%s: %s"), "lpadmin", cupsLastErrorString());
return (1);
}
else
return (0);
}
ipp_t * /* O - Response data */
cupsDoFileRequest(http_t *http, /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
ipp_t *request, /* I - IPP request */
const char *resource, /* I - HTTP resource for POST */
const char *filename) /* I - File to send or @code NULL@ for none */
{
ipp_t *response; /* IPP response data */
int infile; /* Input file */
DEBUG_printf(("cupsDoFileRequest(http=%p, request=%p(%s), resource=\"%s\", "
"filename=\"%s\")", http, request,
request ? ippOpString(request->request.op.operation_id) : "?",
resource, filename));
if (filename)
{
if ((infile = open(filename, O_RDONLY | O_BINARY)) < 0)
{
/*
* Can't get file information!
*/
_cupsSetError(errno == ENOENT ? IPP_STATUS_ERROR_NOT_FOUND : IPP_STATUS_ERROR_NOT_AUTHORIZED,
NULL, 0);
ippDelete(request);
return (NULL);
}
}
else
infile = -1;
response = cupsDoIORequest(http, request, resource, infile, -1);
if (infile >= 0)
close(infile);
return (response);
}
void KCupsConnection::cancelDBusSubscription()
{
do {
ipp_t *request;
// Lets create the request
request = ippNewRequest(IPP_CANCEL_SUBSCRIPTION);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
KCUPS_PRINTER_URI, NULL, "/");
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
"requesting-user-name", NULL, cupsUser());
ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER,
"notify-subscription-id", m_subscriptionId);
// Do the request
ippDelete(cupsDoRequest(CUPS_HTTP_DEFAULT, request, "/"));
} while (retry("/"));
// Reset the subscription id
m_subscriptionId = -1;
}
void
serverDeleteJob(server_job_t *job) /* I - Job */
{
serverLogJob(SERVER_LOGLEVEL_DEBUG, job, "Removing job #%d from history.", job->id);
_cupsRWLockWrite(&job->rwlock);
ippDelete(job->attrs);
if (job->filename)
{
if (!KeepFiles)
unlink(job->filename);
free(job->filename);
}
_cupsRWDeinit(&job->rwlock);
free(job);
}
static void
_post_read_response (GtkCupsRequest *request)
{
ipp_state_t ipp_status;
GTK_NOTE (PRINTING,
g_print ("CUPS Backend: %s\n", G_STRFUNC));
request->poll_state = GTK_CUPS_HTTP_READ;
if (request->result->ipp_response == NULL)
request->result->ipp_response = ippNew();
ipp_status = ippRead (request->http,
request->result->ipp_response);
if (ipp_status == IPP_ERROR)
{
int ipp_error = cupsLastError ();
gtk_cups_result_set_error (request->result,
GTK_CUPS_ERROR_IPP,
ipp_status,
ipp_error,
"%s",
ippErrorString (ipp_error));
ippDelete (request->result->ipp_response);
request->result->ipp_response = NULL;
request->state = GTK_CUPS_POST_DONE;
request->poll_state = GTK_CUPS_HTTP_IDLE;
}
else if (ipp_status == IPP_DATA)
{
request->state = GTK_CUPS_POST_DONE;
request->poll_state = GTK_CUPS_HTTP_IDLE;
}
}
ipp_status_t /* O - IPP status code */
cupsCreateDestJob(
http_t *http, /* I - Connection to destination */
cups_dest_t *dest, /* I - Destination */
cups_dinfo_t *info, /* I - Destination information */
int *job_id, /* O - Job ID or 0 on error */
const char *title, /* I - Job name */
int num_options, /* I - Number of job options */
cups_option_t *options) /* I - Job options */
{
ipp_t *request, /* Create-Job request */
*response; /* Create-Job response */
ipp_attribute_t *attr; /* job-id attribute */
DEBUG_printf(("cupsCreateDestJob(http=%p, dest=%p(%s/%s), info=%p, "
"job_id=%p, title=\"%s\", num_options=%d, options=%p)",
http, dest, dest ? dest->name : NULL,
dest ? dest->instance : NULL, info, job_id, title, num_options,
options));
/*
* Range check input...
*/
if (job_id)
*job_id = 0;
if (!http || !dest || !info || !job_id)
{
_cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(EINVAL), 0);
DEBUG_puts("1cupsCreateDestJob: Bad arguments.");
return (IPP_STATUS_ERROR_INTERNAL);
}
/*
* Build a Create-Job request...
*/
if ((request = ippNewRequest(IPP_OP_CREATE_JOB)) == NULL)
{
_cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(ENOMEM), 0);
DEBUG_puts("1cupsCreateDestJob: Unable to create Create-Job request.");
return (IPP_STATUS_ERROR_INTERNAL);
}
ippSetVersion(request, info->version / 10, info->version % 10);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
NULL, info->uri);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
NULL, cupsUser());
if (title)
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "job-name", NULL,
title);
cupsEncodeOptions2(request, num_options, options, IPP_TAG_OPERATION);
cupsEncodeOptions2(request, num_options, options, IPP_TAG_JOB);
cupsEncodeOptions2(request, num_options, options, IPP_TAG_SUBSCRIPTION);
/*
* Send the request and get the job-id...
*/
response = cupsDoRequest(http, request, info->resource);
if ((attr = ippFindAttribute(response, "job-id", IPP_TAG_INTEGER)) != NULL)
{
*job_id = attr->values[0].integer;
DEBUG_printf(("1cupsCreateDestJob: job-id=%d", *job_id));
}
ippDelete(response);
/*
* Return the status code from the Create-Job request...
*/
DEBUG_printf(("1cupsCreateDestJob: %s (%s)", ippErrorString(cupsLastError()),
cupsLastErrorString()));
return (cupsLastError());
}
int /* O - Exit status */
main(int argc, /* I - Number of command-line args */
char *argv[]) /* I - Command-line arguments */
{
ipp_t *msg; /* Event message from scheduler */
ipp_state_t state; /* IPP event state */
struct sigaction action; /* POSIX sigaction data */
DBusConnection *con = NULL; /* Connection to DBUS server */
DBusError error; /* Error, if any */
DBusMessage *message; /* Message to send */
DBusMessageIter iter; /* Iterator for message data */
int lock_fd = -1; /* Lock file descriptor */
/*
* Don't buffer stderr...
*/
setbuf(stderr, NULL);
/*
* Ignore SIGPIPE signals...
*/
memset(&action, 0, sizeof(action));
action.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &action, NULL);
/*
* Validate command-line options...
*/
if (argc != 3)
{
fputs("Usage: dbus dbus:/// notify-user-data\n", stderr);
return (1);
}
if (strncmp(argv[1], "dbus:", 5))
{
fprintf(stderr, "ERROR: Bad URI \"%s\"!\n", argv[1]);
return (1);
}
/*
* Loop forever until we run out of events...
*/
for (;;)
{
ipp_attribute_t *attr; /* Current attribute */
const char *event; /* Event name */
const char *signame = NULL;/* DBUS signal name */
char *printer_reasons = NULL;
/* Printer reasons string */
char *job_reasons = NULL;
/* Job reasons string */
const char *nul = ""; /* Empty string value */
int no = 0; /* Boolean "no" value */
int params = PARAMS_NONE;
/* What parameters to include? */
/*
* Get the next event...
*/
msg = ippNew();
while ((state = ippReadFile(0, msg)) != IPP_DATA)
{
if (state <= IPP_IDLE)
break;
}
fprintf(stderr, "DEBUG: state=%d\n", state);
if (state == IPP_ERROR)
fputs("DEBUG: ippReadFile() returned IPP_ERROR!\n", stderr);
if (state <= IPP_IDLE)
{
/*
* Out of messages, free memory and then exit...
*/
ippDelete(msg);
break;
}
/*
* Verify connection to DBUS server...
*/
if (con && !dbus_connection_get_is_connected(con))
{
dbus_connection_unref(con);
con = NULL;
}
if (!con)
{
dbus_error_init(&error);
con = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
if (!con)
dbus_error_free(&error);
else
fputs("DEBUG: Connected to D-BUS\n", stderr);
}
if (!con)
continue;
if (lock_fd == -1 &&
acquire_lock(&lock_fd, lock_filename, sizeof(lock_filename)))
continue;
attr = ippFindAttribute(msg, "notify-subscribed-event",
IPP_TAG_KEYWORD);
if (!attr)
continue;
event = ippGetString(attr, 0, NULL);
if (!strncmp(event, "server-", 7))
{
const char *word2 = event + 7; /* Second word */
if (!strcmp(word2, "restarted"))
signame = "ServerRestarted";
else if (!strcmp(word2, "started"))
signame = "ServerStarted";
else if (!strcmp(word2, "stopped"))
signame = "ServerStopped";
else if (!strcmp(word2, "audit"))
signame = "ServerAudit";
else
continue;
}
else if (!strncmp(event, "printer-", 8))
{
const char *word2 = event + 8; /* Second word */
params = PARAMS_PRINTER;
if (!strcmp(word2, "restarted"))
signame = "PrinterRestarted";
else if (!strcmp(word2, "shutdown"))
signame = "PrinterShutdown";
else if (!strcmp(word2, "stopped"))
signame = "PrinterStopped";
else if (!strcmp(word2, "state-changed"))
signame = "PrinterStateChanged";
else if (!strcmp(word2, "finishings-changed"))
signame = "PrinterFinishingsChanged";
else if (!strcmp(word2, "media-changed"))
signame = "PrinterMediaChanged";
else if (!strcmp(word2, "added"))
signame = "PrinterAdded";
else if (!strcmp(word2, "deleted"))
signame = "PrinterDeleted";
else if (!strcmp(word2, "modified"))
signame = "PrinterModified";
else
continue;
}
else if (!strncmp(event, "job-", 4))
{
const char *word2 = event + 4; /* Second word */
params = PARAMS_JOB;
if (!strcmp(word2, "state-changed"))
signame = "JobState";
else if (!strcmp(word2, "created"))
signame = "JobCreated";
else if (!strcmp(word2, "completed"))
signame = "JobCompleted";
else if (!strcmp(word2, "stopped"))
signame = "JobStopped";
else if (!strcmp(word2, "config-changed"))
signame = "JobConfigChanged";
else if (!strcmp(word2, "progress"))
signame = "JobProgress";
else
continue;
}
else
continue;
/*
* Create and send the new message...
*/
fprintf(stderr, "DEBUG: %s\n", signame);
message = dbus_message_new_signal("/org/cups/cupsd/Notifier",
"org.cups.cupsd.Notifier",
signame);
dbus_message_append_iter_init(message, &iter);
attr = ippFindAttribute(msg, "notify-text", IPP_TAG_TEXT);
if (attr)
{
const char *val = ippGetString(attr, 0, NULL);
if (!dbus_message_iter_append_string(&iter, &val))
goto bail;
}
else
goto bail;
if (params >= PARAMS_PRINTER)
{
char *p; /* Pointer into printer_reasons */
size_t reasons_length; /* Required size of printer_reasons */
int i; /* Looping var */
int have_printer_params = 1;/* Do we have printer URI? */
/* STRING printer-uri or "" */
attr = ippFindAttribute(msg, "notify-printer-uri", IPP_TAG_URI);
if (attr)
{
const char *val = ippGetString(attr, 0, NULL);
if (!dbus_message_iter_append_string(&iter, &val))
goto bail;
}
else
{
have_printer_params = 0;
dbus_message_iter_append_string(&iter, &nul);
}
/* STRING printer-name */
if (have_printer_params)
{
attr = ippFindAttribute(msg, "printer-name", IPP_TAG_NAME);
if (attr)
{
const char *val = ippGetString(attr, 0, NULL);
if (!dbus_message_iter_append_string(&iter, &val))
goto bail;
}
else
goto bail;
}
else
dbus_message_iter_append_string(&iter, &nul);
/* UINT32 printer-state */
if (have_printer_params)
{
attr = ippFindAttribute(msg, "printer-state", IPP_TAG_ENUM);
if (attr)
{
dbus_uint32_t val = ippGetInteger(attr, 0);
dbus_message_iter_append_uint32(&iter, &val);
}
else
goto bail;
}
else
dbus_message_iter_append_uint32(&iter, &no);
/* STRING printer-state-reasons */
if (have_printer_params)
{
attr = ippFindAttribute(msg, "printer-state-reasons",
IPP_TAG_KEYWORD);
if (attr)
{
int num_values = ippGetCount(attr);
for (reasons_length = 0, i = 0; i < num_values; i++)
/* All need commas except the last, which needs a nul byte. */
reasons_length += 1 + strlen(ippGetString(attr, i, NULL));
printer_reasons = malloc(reasons_length);
if (!printer_reasons)
goto bail;
p = printer_reasons;
for (i = 0; i < num_values; i++)
{
if (i)
*p++ = ',';
strlcpy(p, ippGetString(attr, i, NULL),
reasons_length - (p - printer_reasons));
p += strlen(p);
}
if (!dbus_message_iter_append_string(&iter, &printer_reasons))
goto bail;
}
else
goto bail;
}
else
dbus_message_iter_append_string(&iter, &nul);
/* BOOL printer-is-accepting-jobs */
if (have_printer_params)
{
attr = ippFindAttribute(msg, "printer-is-accepting-jobs",
IPP_TAG_BOOLEAN);
if (attr)
{
dbus_bool_t val = ippGetBoolean(attr, 0);
dbus_message_iter_append_boolean(&iter, &val);
}
else
goto bail;
}
else
dbus_message_iter_append_boolean(&iter, &no);
}
if (params >= PARAMS_JOB)
{
char *p; /* Pointer into job_reasons */
size_t reasons_length; /* Required size of job_reasons */
int i; /* Looping var */
/* UINT32 job-id */
attr = ippFindAttribute(msg, "notify-job-id", IPP_TAG_INTEGER);
if (attr)
{
dbus_uint32_t val = ippGetInteger(attr, 0);
dbus_message_iter_append_uint32(&iter, &val);
}
else
goto bail;
/* UINT32 job-state */
attr = ippFindAttribute(msg, "job-state", IPP_TAG_ENUM);
if (attr)
{
dbus_uint32_t val = ippGetInteger(attr, 0);
dbus_message_iter_append_uint32(&iter, &val);
}
else
goto bail;
/* STRING job-state-reasons */
attr = ippFindAttribute(msg, "job-state-reasons", IPP_TAG_KEYWORD);
if (attr)
{
int num_values = ippGetCount(attr);
for (reasons_length = 0, i = 0; i < num_values; i++)
/* All need commas except the last, which needs a nul byte. */
reasons_length += 1 + strlen(ippGetString(attr, i, NULL));
job_reasons = malloc(reasons_length);
if (!job_reasons)
goto bail;
p = job_reasons;
for (i = 0; i < num_values; i++)
{
if (i)
*p++ = ',';
strlcpy(p, ippGetString(attr, i, NULL),
reasons_length - (p - job_reasons));
p += strlen(p);
}
if (!dbus_message_iter_append_string(&iter, &job_reasons))
goto bail;
}
else
goto bail;
/* STRING job-name or "" */
attr = ippFindAttribute(msg, "job-name", IPP_TAG_NAME);
if (attr)
{
const char *val = ippGetString(attr, 0, NULL);
if (!dbus_message_iter_append_string(&iter, &val))
goto bail;
}
else
dbus_message_iter_append_string(&iter, &nul);
/* UINT32 job-impressions-completed */
attr = ippFindAttribute(msg, "job-impressions-completed",
IPP_TAG_INTEGER);
if (attr)
{
dbus_uint32_t val = ippGetInteger(attr, 0);
dbus_message_iter_append_uint32(&iter, &val);
}
else
goto bail;
}
dbus_connection_send(con, message, NULL);
dbus_connection_flush(con);
/*
* Cleanup...
*/
bail:
dbus_message_unref(message);
if (printer_reasons)
free(printer_reasons);
if (job_reasons)
free(job_reasons);
ippDelete(msg);
}
/*
* Remove lock file...
*/
if (lock_fd >= 0)
{
close(lock_fd);
release_lock();
}
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 */
const char *opt, /* Current option character */
*name = NULL, /* Service name */
*type = "_ipp._tcp", /* Service type */
*domain = "local."; /* Service domain */
#ifdef HAVE_DNSSD
DNSServiceRef ref; /* Browsing service reference */
#endif /* HAVE_DNSSD */
#ifdef HAVE_AVAHI
AvahiClient *client; /* Client information */
int error; /* Error code, if any */
#endif /* HAVE_AVAHI */
for (i = 1; i < argc; i ++)
if (!strcmp(argv[i], "snmp"))
snmponly = 1;
else if (!strcmp(argv[i], "ipp"))
ipponly = 1;
else
{
puts("Usage: ./ipp-printers [{ipp | snmp}]");
return (1);
}
/*
* Create an array to track devices...
*/
devices = cupsArrayNew((cups_array_func_t)compare_devices, NULL);
/*
* Browse for different kinds of printers...
*/
if (DNSServiceCreateConnection(&main_ref) != kDNSServiceErr_NoError)
{
perror("ERROR: Unable to create service connection");
return (1);
}
fd = DNSServiceRefSockFD(main_ref);
ipp_ref = main_ref;
DNSServiceBrowse(&ipp_ref, kDNSServiceFlagsShareConnection, 0,
"_ipp._tcp", NULL, browse_callback, devices);
/*
* Loop until we are killed...
*/
progress();
for (;;)
{
FD_ZERO(&input);
FD_SET(fd, &input);
timeout.tv_sec = 2;
timeout.tv_usec = 500000;
if (select(fd + 1, &input, NULL, NULL, &timeout) <= 0)
{
time_t curtime = time(NULL);
for (device = (cups_device_t *)cupsArrayFirst(devices);
device;
device = (cups_device_t *)cupsArrayNext(devices))
if (!device->got_resolve)
{
if (!device->ref)
break;
if ((curtime - device->resolve_time) > 10)
{
device->got_resolve = -1;
fprintf(stderr, "\rUnable to resolve \"%s\": timeout\n",
device->name);
progress();
}
else
break;
}
if (!device)
break;
}
if (FD_ISSET(fd, &input))
{
/*
* Process results of our browsing...
*/
progress();
DNSServiceProcessResult(main_ref);
}
else
{
/*
* Query any devices we've found...
*/
DNSServiceErrorType status; /* DNS query status */
int count; /* Number of queries */
for (device = (cups_device_t *)cupsArrayFirst(devices), count = 0;
device;
device = (cups_device_t *)cupsArrayNext(devices))
{
if (!device->ref && !device->sent)
{
/*
* Found the device, now get the TXT record(s) for it...
*/
if (count < 50)
{
device->resolve_time = time(NULL);
device->ref = main_ref;
status = DNSServiceResolve(&(device->ref),
kDNSServiceFlagsShareConnection,
0, device->name, device->regtype,
device->domain, resolve_callback,
device);
if (status != kDNSServiceErr_NoError)
{
fprintf(stderr, "\rUnable to resolve \"%s\": %d\n",
device->name, status);
progress();
}
else
count ++;
}
}
else if (!device->sent && device->got_resolve)
{
/*
* Got the TXT records, now report the device...
*/
DNSServiceRefDeallocate(device->ref);
device->ref = 0;
device->sent = 1;
}
}
}
}
#ifndef DEBUG
fprintf(stderr, "\rFound %d printers. Now querying for capabilities...\n",
cupsArrayCount(devices));
#endif /* !DEBUG */
puts("#!/bin/sh -x");
puts("test -d results && rm -rf results");
puts("mkdir results");
puts("CUPS_DEBUG_LEVEL=6; export CUPS_DEBUG_LEVEL");
puts("CUPS_DEBUG_FILTER='^(ipp|http|_ipp|_http|cupsGetResponse|cupsSend|"
"cupsWrite|cupsDo).*'; export CUPS_DEBUG_FILTER");
for (device = (cups_device_t *)cupsArrayFirst(devices);
device;
device = (cups_device_t *)cupsArrayNext(devices))
{
if (device->got_resolve <= 0 || device->cups_shared)
continue;
#ifdef DEBUG
fprintf(stderr, "Checking \"%s\" (got_resolve=%d, cups_shared=%d, uri=%s)\n",
device->name, device->got_resolve, device->cups_shared, device->uri);
#else
fprintf(stderr, "Checking \"%s\"...\n", device->name);
#endif /* DEBUG */
if ((http = httpConnect(device->host, device->port)) == NULL)
{
fprintf(stderr, "Failed to connect to \"%s\": %s\n", device->name,
cupsLastErrorString());
continue;
}
request = ippNewRequest(IPP_GET_PRINTER_ATTRIBUTES);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL,
device->uri);
response = cupsDoRequest(http, request, device->rp);
if (cupsLastError() > IPP_OK_SUBST)
fprintf(stderr, "Failed to query \"%s\": %s\n", device->name,
cupsLastErrorString());
else
{
if ((attr = ippFindAttribute(response, "ipp-versions-supported",
IPP_TAG_KEYWORD)) != NULL)
{
version = attr->values[0].string.text;
for (i = 1; i < attr->num_values; i ++)
if (strcmp(attr->values[i].string.text, version) > 0)
version = attr->values[i].string.text;
}
else
version = "1.0";
testfile = NULL;
if ((attr = ippFindAttribute(response, "document-format-supported",
IPP_TAG_MIMETYPE)) != NULL)
{
/*
* Figure out the test file for printing, preferring PDF and PostScript
* over JPEG and plain text...
*/
for (i = 0; i < attr->num_values; i ++)
{
if (!strcasecmp(attr->values[i].string.text, "application/pdf"))
{
testfile = "testfile.pdf";
break;
}
else if (!strcasecmp(attr->values[i].string.text,
"application/postscript"))
testfile = "testfile.ps";
else if (!strcasecmp(attr->values[i].string.text, "image/jpeg") &&
!testfile)
testfile = "testfile.jpg";
else if (!strcasecmp(attr->values[i].string.text, "text/plain") &&
!testfile)
testfile = "testfile.txt";
else if (!strcasecmp(attr->values[i].string.text,
"application/vnd.hp-PCL") && !testfile)
testfile = "testfile.pcl";
}
if (!testfile)
{
fprintf(stderr,
"Printer \"%s\" reports the following IPP file formats:\n",
device->name);
for (i = 0; i < attr->num_values; i ++)
fprintf(stderr, " \"%s\"\n", attr->values[i].string.text);
}
}
if (!testfile && device->pdl)
{
char *pdl, /* Copy of pdl string */
*start, *end; /* Pointers into pdl string */
pdl = strdup(device->pdl);
for (start = device->pdl; start && *start; start = end)
{
if ((end = strchr(start, ',')) != NULL)
*end++ = '\0';
if (!strcasecmp(start, "application/pdf"))
{
testfile = "testfile.pdf";
break;
}
else if (!strcasecmp(start, "application/postscript"))
testfile = "testfile.ps";
else if (!strcasecmp(start, "image/jpeg") && !testfile)
testfile = "testfile.jpg";
else if (!strcasecmp(start, "text/plain") && !testfile)
testfile = "testfile.txt";
else if (!strcasecmp(start, "application/vnd.hp-PCL") && !testfile)
testfile = "testfile.pcl";
}
free(pdl);
if (testfile)
{
fprintf(stderr,
"Using \"%s\" for printer \"%s\" based on TXT record pdl "
"info.\n", testfile, device->name);
}
else
{
fprintf(stderr,
"Printer \"%s\" reports the following TXT file formats:\n",
device->name);
fprintf(stderr, " \"%s\"\n", device->pdl);
}
}
if (!device->ty &&
(attr = ippFindAttribute(response, "printer-make-and-model",
IPP_TAG_TEXT)) != NULL)
device->ty = strdup(attr->values[0].string.text);
if (strcmp(version, "1.0") && testfile && device->ty)
{
char filename[1024], /* Filename */
*fileptr; /* Pointer into filename */
const char *typtr; /* Pointer into ty */
if (!strncasecmp(device->ty, "DeskJet", 7) ||
!strncasecmp(device->ty, "DesignJet", 9) ||
!strncasecmp(device->ty, "OfficeJet", 9) ||
!strncasecmp(device->ty, "Photosmart", 10))
strlcpy(filename, "HP_", sizeof(filename));
else
filename[0] = '\0';
fileptr = filename + strlen(filename);
if (!strncasecmp(device->ty, "Lexmark International Lexmark", 29))
typtr = device->ty + 22;
else
typtr = device->ty;
while (*typtr && fileptr < (filename + sizeof(filename) - 1))
{
if (isalnum(*typtr & 255) || *typtr == '-')
*fileptr++ = *typtr++;
else
{
*fileptr++ = '_';
typtr++;
}
}
*fileptr = '\0';
printf("# %s\n", device->name);
printf("echo \"Testing %s...\"\n", device->name);
if (!ipponly)
{
printf("echo \"snmpwalk -c public -v 1 -Cc %s 1.3.6.1.2.1.25 "
"1.3.6.1.2.1.43 1.3.6.1.4.1.2699.1\" > results/%s.snmpwalk\n",
device->host, filename);
printf("snmpwalk -c public -v 1 -Cc %s 1.3.6.1.2.1.25 "
"1.3.6.1.2.1.43 1.3.6.1.4.1.2699.1 | "
"tee -a results/%s.snmpwalk\n",
device->host, filename);
}
if (!snmponly)
{
printf("echo \"./ipptool-static -tIf %s -T 30 -d NOPRINT=1 -V %s %s "
"ipp-%s.test\" > results/%s.log\n", testfile, version,
device->uri, version, filename);
printf("CUPS_DEBUG_LOG=results/%s.debug_log "
"./ipptool-static -tIf %s -T 30 -d NOPRINT=1 -V %s %s "
"ipp-%s.test | tee -a results/%s.log\n", filename,
testfile, version, device->uri,
version, filename);
}
puts("");
}
else if (!device->ty)
fprintf(stderr,
"Ignoring \"%s\" since it doesn't provide a make and model.\n",
device->name);
else if (!testfile)
fprintf(stderr,
"Ignoring \"%s\" since it does not support a common format.\n",
device->name);
else
fprintf(stderr, "Ignoring \"%s\" since it only supports IPP/1.0.\n",
device->name);
}
ippDelete(response);
httpClose(http);
}
return (0);
}
int /* O - Exit status */
main(int argc, /* I - Number of command-line args */
char *argv[]) /* I - Command-line arguments */
{
int status; /* Status of tests (0 = success, 1 = fail) */
const char *ppdfile; /* PPD filename */
ppd_file_t *ppd; /* PPD file */
_ppd_cache_t *pc; /* PPD cache and PWG mapping data */
const pwg_media_t *pwgmedia; /* PWG media size */
size_t i, /* Looping var */
num_media; /* Number of media sizes */
const pwg_media_t *mediatable; /* Media size table */
int dupmedia = 0; /* Duplicate media sizes? */
status = 0;
if (argc < 2 || argc > 3)
{
puts("Usage: ./testpwg filename.ppd [jobfile]");
return (1);
}
ppdfile = argv[1];
printf("ppdOpenFile(%s): ", ppdfile);
if ((ppd = ppdOpenFile(ppdfile)) == NULL)
{
ppd_status_t err; /* Last error in file */
int line; /* Line number in file */
err = ppdLastError(&line);
printf("FAIL (%s on line %d)\n", ppdErrorString(err), line);
return (1);
}
else
puts("PASS");
fputs("_ppdCacheCreateWithPPD(ppd): ", stdout);
if ((pc = _ppdCacheCreateWithPPD(ppd)) == NULL)
{
puts("FAIL");
status ++;
}
else
{
puts("PASS");
status += test_ppd_cache(pc, ppd);
if (argc == 3)
{
/*
* Test PageSize mapping code.
*/
int fd; /* Job file descriptor */
const char *pagesize; /* PageSize value */
ipp_t *job; /* Job attributes */
ipp_attribute_t *media; /* Media attribute */
if ((fd = open(argv[2], O_RDONLY)) >= 0)
{
job = ippNew();
ippReadFile(fd, job);
close(fd);
if ((media = ippFindAttribute(job, "media", IPP_TAG_ZERO)) != NULL &&
media->value_tag != IPP_TAG_NAME &&
media->value_tag != IPP_TAG_KEYWORD)
media = NULL;
if (media)
printf("_ppdCacheGetPageSize(media=%s): ",
media->values[0].string.text);
else
fputs("_ppdCacheGetPageSize(media-col): ", stdout);
fflush(stdout);
if ((pagesize = _ppdCacheGetPageSize(pc, job, NULL, NULL)) == NULL)
{
puts("FAIL (Not Found)");
status = 1;
}
else if (media && _cups_strcasecmp(pagesize, media->values[0].string.text))
{
printf("FAIL (Got \"%s\", Expected \"%s\")\n", pagesize,
media->values[0].string.text);
status = 1;
}
else
printf("PASS (%s)\n", pagesize);
ippDelete(job);
}
else
{
perror(argv[2]);
status = 1;
}
}
/*
* _ppdCacheDestroy should never fail...
*/
fputs("_ppdCacheDestroy(pc): ", stdout);
_ppdCacheDestroy(pc);
puts("PASS");
}
fputs("pwgMediaForPWG(\"iso_a4_210x297mm\"): ", stdout);
if ((pwgmedia = pwgMediaForPWG("iso_a4_210x297mm")) == NULL)
{
puts("FAIL (not found)");
status ++;
}
else if (strcmp(pwgmedia->pwg, "iso_a4_210x297mm"))
{
printf("FAIL (%s)\n", pwgmedia->pwg);
status ++;
}
else if (pwgmedia->width != 21000 || pwgmedia->length != 29700)
{
printf("FAIL (%dx%d)\n", pwgmedia->width, pwgmedia->length);
status ++;
}
else
puts("PASS");
fputs("pwgMediaForPWG(\"roll_max_36.1025x3622.0472in\"): ", stdout);
if ((pwgmedia = pwgMediaForPWG("roll_max_36.1025x3622.0472in")) == NULL)
{
puts("FAIL (not found)");
status ++;
}
else if (pwgmedia->width != 91700 || pwgmedia->length != 9199999)
{
printf("FAIL (%dx%d)\n", pwgmedia->width, pwgmedia->length);
status ++;
}
else
printf("PASS (%dx%d)\n", pwgmedia->width, pwgmedia->length);
fputs("pwgMediaForLegacy(\"na-letter\"): ", stdout);
if ((pwgmedia = pwgMediaForLegacy("na-letter")) == NULL)
{
puts("FAIL (not found)");
status ++;
}
else if (strcmp(pwgmedia->pwg, "na_letter_8.5x11in"))
{
printf("FAIL (%s)\n", pwgmedia->pwg);
status ++;
}
else if (pwgmedia->width != 21590 || pwgmedia->length != 27940)
{
printf("FAIL (%dx%d)\n", pwgmedia->width, pwgmedia->length);
status ++;
}
else
puts("PASS");
fputs("pwgMediaForPPD(\"4x6\"): ", stdout);
if ((pwgmedia = pwgMediaForPPD("4x6")) == NULL)
{
puts("FAIL (not found)");
status ++;
}
else if (strcmp(pwgmedia->pwg, "na_index-4x6_4x6in"))
{
printf("FAIL (%s)\n", pwgmedia->pwg);
status ++;
}
else if (pwgmedia->width != 10160 || pwgmedia->length != 15240)
{
printf("FAIL (%dx%d)\n", pwgmedia->width, pwgmedia->length);
status ++;
}
else
puts("PASS");
fputs("pwgMediaForPPD(\"10x15cm\"): ", stdout);
if ((pwgmedia = pwgMediaForPPD("10x15cm")) == NULL)
{
puts("FAIL (not found)");
status ++;
}
else if (strcmp(pwgmedia->pwg, "om_100x150mm_100x150mm"))
{
printf("FAIL (%s)\n", pwgmedia->pwg);
status ++;
}
else if (pwgmedia->width != 10000 || pwgmedia->length != 15000)
{
printf("FAIL (%dx%d)\n", pwgmedia->width, pwgmedia->length);
status ++;
}
else
puts("PASS");
fputs("pwgMediaForPPD(\"Custom.10x15cm\"): ", stdout);
if ((pwgmedia = pwgMediaForPPD("Custom.10x15cm")) == NULL)
{
puts("FAIL (not found)");
status ++;
}
else if (strcmp(pwgmedia->pwg, "custom_10x15cm_100x150mm"))
{
printf("FAIL (%s)\n", pwgmedia->pwg);
status ++;
}
else if (pwgmedia->width != 10000 || pwgmedia->length != 15000)
{
printf("FAIL (%dx%d)\n", pwgmedia->width, pwgmedia->length);
status ++;
}
else
puts("PASS");
fputs("pwgMediaForSize(29700, 42000): ", stdout);
if ((pwgmedia = pwgMediaForSize(29700, 42000)) == NULL)
{
puts("FAIL (not found)");
status ++;
}
else if (strcmp(pwgmedia->pwg, "iso_a3_297x420mm"))
{
printf("FAIL (%s)\n", pwgmedia->pwg);
status ++;
}
else
puts("PASS");
fputs("pwgMediaForSize(9842, 19050): ", stdout);
if ((pwgmedia = pwgMediaForSize(9842, 19050)) == NULL)
{
puts("FAIL (not found)");
status ++;
}
else if (strcmp(pwgmedia->pwg, "na_monarch_3.875x7.5in"))
{
printf("FAIL (%s)\n", pwgmedia->pwg);
status ++;
}
else
printf("PASS (%s)\n", pwgmedia->pwg);
fputs("pwgMediaForSize(9800, 19000): ", stdout);
if ((pwgmedia = pwgMediaForSize(9800, 19000)) == NULL)
{
puts("FAIL (not found)");
status ++;
}
else if (strcmp(pwgmedia->pwg, "jpn_you6_98x190mm"))
{
printf("FAIL (%s)\n", pwgmedia->pwg);
status ++;
}
else
printf("PASS (%s)\n", pwgmedia->pwg);
fputs("Duplicate size test: ", stdout);
for (mediatable = _pwgMediaTable(&num_media);
num_media > 1;
num_media --, mediatable ++)
{
for (i = num_media - 1, pwgmedia = mediatable + 1; i > 0; i --, pwgmedia ++)
{
if (pwgmedia->width == mediatable->width &&
pwgmedia->length == mediatable->length)
{
if (!dupmedia)
{
dupmedia = 1;
status ++;
puts("FAIL");
}
printf(" %s and %s have the same dimensions (%dx%d)\n",
pwgmedia->pwg, mediatable->pwg, pwgmedia->width,
pwgmedia->length);
}
}
}
if (!dupmedia)
puts("PASS");
return (status);
}
static int /* O - Exit status */
do_test(const char *server, /* I - Server to use */
http_encryption_t encryption, /* I - Encryption to use */
int requests, /* I - Number of requests to send */
int verbose) /* I - Verbose output? */
{
int i; /* Looping var */
http_t *http; /* Connection to server */
ipp_t *request, /* IPP Request */
*response; /* IPP Response */
cups_lang_t *language; /* Default language */
struct timeval start, /* Start time */
end; /* End time */
double elapsed; /* Elapsed time */
static ipp_op_t ops[4] = /* Operations to test... */
{
IPP_PRINT_JOB,
CUPS_GET_PRINTERS,
CUPS_GET_CLASSES,
IPP_GET_JOBS
};
/*
* Connect to the server...
*/
http = httpConnectEncrypt(server, ippPort(), encryption);
if (http == NULL)
{
perror("testspeed: unable to connect to server");
return (1);
}
language = cupsLangDefault();
/*
* Do multiple requests...
*/
for (elapsed = 0.0, i = 0; i < requests; i ++)
{
if (verbose && (i % 10) == 0)
printf("testspeed(%d): %d%% complete...\n", (int)getpid(),
i * 100 / requests);
/*
* Build a request which requires the following attributes:
*
* attributes-charset
* attributes-natural-language
*
* In addition, IPP_GET_JOBS needs a printer-uri attribute.
*/
request = ippNew();
request->request.op.operation_id = ops[i & 3];
request->request.op.request_id = 1;
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
"attributes-charset", NULL, cupsLangEncoding(language));
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
gettimeofday(&start, NULL);
switch (request->request.op.operation_id)
{
case IPP_GET_JOBS :
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
NULL, "ipp://localhost/printers/");
default :
response = cupsDoRequest(http, request, "/");
break;
case IPP_PRINT_JOB :
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
NULL, "ipp://localhost/printers/test");
response = cupsDoFileRequest(http, request, "/printers/test",
"../data/testprint.ps");
break;
}
gettimeofday(&end, NULL);
if (response != NULL)
ippDelete(response);
elapsed += (end.tv_sec - start.tv_sec) +
0.000001 * (end.tv_usec - start.tv_usec);
}
cupsLangFree(language);
httpClose(http);
printf("testspeed(%d): %d requests in %.1fs (%.3fs/r, %.1fr/s)\n",
(int)getpid(), i, elapsed, elapsed / i, i / elapsed);
return (0);
}
http_status_t /* O - Status of document creation */
cupsStartDestDocument(
http_t *http, /* I - Connection to destination */
cups_dest_t *dest, /* I - Destination */
cups_dinfo_t *info, /* I - Destination information */
int job_id, /* I - Job ID */
const char *docname, /* I - Document name */
const char *format, /* I - Document format */
int num_options, /* I - Number of document options */
cups_option_t *options, /* I - Document options */
int last_document) /* I - 1 if this is the last document */
{
ipp_t *request; /* Send-Document request */
http_status_t status; /* HTTP status */
DEBUG_printf(("cupsStartDestDocument(http=%p, dest=%p(%s/%s), info=%p, "
"job_id=%d, docname=\"%s\", format=\"%s\", num_options=%d, "
"options=%p, last_document=%d)",
http, dest, dest ? dest->name : NULL,
dest ? dest->instance : NULL, info, job_id, docname, format,
num_options, options, last_document));
/*
* Range check input...
*/
if (!http || !dest || !info || job_id <= 0)
{
_cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(EINVAL), 0);
DEBUG_puts("1cupsStartDestDocument: Bad arguments.");
return (HTTP_STATUS_ERROR);
}
/*
* Create a Send-Document request...
*/
if ((request = ippNewRequest(IPP_OP_SEND_DOCUMENT)) == NULL)
{
_cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(ENOMEM), 0);
DEBUG_puts("1cupsStartDestDocument: Unable to create Send-Document "
"request.");
return (HTTP_STATUS_ERROR);
}
ippSetVersion(request, info->version / 10, info->version % 10);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
NULL, info->uri);
ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id", job_id);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
NULL, cupsUser());
if (docname)
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "document-name",
NULL, docname);
if (format)
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE,
"document-format", NULL, format);
ippAddBoolean(request, IPP_TAG_OPERATION, "last-document", last_document);
cupsEncodeOptions2(request, num_options, options, IPP_TAG_OPERATION);
cupsEncodeOptions2(request, num_options, options, IPP_TAG_DOCUMENT);
/*
* Send and delete the request, then return the status...
*/
status = cupsSendRequest(http, request, info->resource, CUPS_LENGTH_VARIABLE);
ippDelete(request);
return (status);
}
static void
_pp_maintenance_command_execute_thread (GSimpleAsyncResult *res,
GObject *object,
GCancellable *cancellable)
{
PpMaintenanceCommand *command = (PpMaintenanceCommand *) object;
PpMaintenanceCommandPrivate *priv = command->priv;
static const char *attrs[] = {"printer-commands"};
ipp_attribute_t *attr = NULL;
gboolean success = FALSE;
GError *error = NULL;
ipp_t *request;
ipp_t *response = NULL;
gchar *printer_uri;
gchar *printer_commands = NULL;
gchar *printer_commands_lowercase = NULL;
gchar *command_lowercase;
gchar *file_name = NULL;
int fd = -1;
printer_uri = g_strdup_printf ("ipp://localhost/printers/%s",
priv->printer_name);
request = ippNewRequest (IPP_GET_PRINTER_ATTRIBUTES);
ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_URI,
"printer-uri", NULL, printer_uri);
ippAddStrings (request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
"requested-attributes", 1, NULL, attrs);
response = cupsDoRequest (CUPS_HTTP_DEFAULT, request, "/");
if (response)
{
if (ippGetStatusCode (response) <= IPP_OK_CONFLICT)
{
attr = ippFindAttribute (response, "printer-commands", IPP_TAG_ZERO);
if (attr && ippGetCount (attr) > 0 && ippGetValueTag (attr) != IPP_TAG_NOVALUE)
{
if (ippGetValueTag (attr) == IPP_TAG_KEYWORD)
{
printer_commands = g_strdup (ippGetString (attr, 0, NULL));
}
}
else
{
success = TRUE;
}
}
ippDelete (response);
}
if (printer_commands)
{
command_lowercase = g_ascii_strdown (priv->command, -1);
printer_commands_lowercase = g_ascii_strdown (printer_commands, -1);
if (g_strrstr (printer_commands_lowercase, command_lowercase))
{
request = ippNewRequest (IPP_PRINT_JOB);
ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_URI,
"printer-uri", NULL, printer_uri);
ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_NAME,
"job-name", NULL, priv->title);
ippAddString (request, IPP_TAG_JOB, IPP_TAG_MIMETYPE,
"document-format", NULL, "application/vnd.cups-command");
fd = g_file_open_tmp ("ccXXXXXX", &file_name, &error);
if (fd != -1)
{
FILE *file;
file = fdopen (fd, "w");
fprintf (file, "#CUPS-COMMAND\n");
fprintf (file, "%s\n", priv->command);
fclose (file);
response = cupsDoFileRequest (CUPS_HTTP_DEFAULT, request, "/", file_name);
g_unlink (file_name);
if (response)
{
if (ippGetStatusCode (response) <= IPP_OK_CONFLICT)
{
success = TRUE;
}
ippDelete (response);
}
}
g_free (file_name);
}
else
{
success = TRUE;
}
g_free (command_lowercase);
g_free (printer_commands_lowercase);
g_free (printer_commands);
}
g_free (printer_uri);
if (!success)
{
g_simple_async_result_set_error (res,
G_IO_ERROR,
G_IO_ERROR_FAILED,
"Execution of maintenance command failed.");
}
g_simple_async_result_set_op_res_gboolean (res, success);
}
int /* O - Number of printers */
cupsGetPrinters(char ***printers) /* O - Printers */
{
int n; /* Number of printers */
ipp_t *request, /* IPP Request */
*response; /* IPP Response */
ipp_attribute_t *attr; /* Current attribute */
char **temp; /* Temporary pointer */
_cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
if (printers == NULL)
{
_cupsSetError(IPP_INTERNAL_ERROR, NULL);
return (0);
}
/*
* Try to connect to the server...
*/
if (!cups_connect("default", NULL, NULL))
{
DEBUG_puts("Unable to connect to server!");
return (0);
}
/*
* Build a CUPS_GET_PRINTERS request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* requested-attributes
*/
request = ippNewRequest(CUPS_GET_PRINTERS);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
"requested-attributes", NULL, "printer-name");
ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_ENUM,
"printer-type", 0);
ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_ENUM,
"printer-type-mask", CUPS_PRINTER_CLASS);
/*
* Do the request and get back a response...
*/
n = 0;
*printers = NULL;
if ((response = cupsDoRequest(cg->http, request, "/")) != NULL)
{
for (attr = response->attrs; attr != NULL; attr = attr->next)
if (attr->name != NULL &&
strcasecmp(attr->name, "printer-name") == 0 &&
attr->value_tag == IPP_TAG_NAME)
{
if (n == 0)
temp = malloc(sizeof(char *));
else
temp = realloc(*printers, sizeof(char *) * (n + 1));
if (temp == NULL)
{
/*
* Ran out of memory!
*/
while (n > 0)
{
n --;
free((*printers)[n]);
}
free(*printers);
ippDelete(response);
return (0);
}
*printers = temp;
temp[n] = strdup(attr->values[0].string.text);
n ++;
}
ippDelete(response);
}
return (n);
}
int /* O - 1 on success, 0 on failure */
cupsCancelJob(const char *name, /* I - Name of printer or class */
int job) /* I - Job ID */
{
char printer[HTTP_MAX_URI], /* Printer name */
hostname[HTTP_MAX_URI], /* Hostname */
uri[HTTP_MAX_URI]; /* Printer URI */
ipp_t *request, /* IPP request */
*response; /* IPP response */
_cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
/*
* See if we can connect to the server...
*/
if (!cups_connect(name, printer, hostname))
{
DEBUG_puts("Unable to connect to server!");
return (0);
}
/*
* Create a printer URI...
*/
if (httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
"localhost", 0, "/printers/%s", printer) != HTTP_URI_OK)
{
_cupsSetError(IPP_INTERNAL_ERROR, NULL);
return (0);
}
/*
* Build an IPP_CANCEL_JOB request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
* job-id
* [requesting-user-name]
*/
request = ippNewRequest(IPP_CANCEL_JOB);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
NULL, uri);
ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id", job);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
NULL, cupsUser());
/*
* Do the request...
*/
if ((response = cupsDoRequest(cg->http, request, "/jobs/")) != NULL)
ippDelete(response);
return (cg->last_error < IPP_REDIRECTION_OTHER_SITE);
}
ipp_status_t /* O - IPP status code */
cupsCloseDestJob(
http_t *http, /* I - Connection to destination */
cups_dest_t *dest, /* I - Destination */
cups_dinfo_t *info, /* I - Destination information */
int job_id) /* I - Job ID */
{
int i; /* Looping var */
ipp_t *request = NULL;/* Close-Job/Send-Document request */
ipp_attribute_t *attr; /* operations-supported attribute */
DEBUG_printf(("cupsCloseDestJob(http=%p, dest=%p(%s/%s), info=%p, job_id=%d)",
http, dest, dest ? dest->name : NULL,
dest ? dest->instance : NULL, info, job_id));
/*
* Range check input...
*/
if (!http || !dest || !info || job_id <= 0)
{
_cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(EINVAL), 0);
DEBUG_puts("1cupsCloseDestJob: Bad arguments.");
return (IPP_STATUS_ERROR_INTERNAL);
}
/*
* Build a Close-Job or empty Send-Document request...
*/
if ((attr = ippFindAttribute(info->attrs, "operations-supported",
IPP_TAG_ENUM)) != NULL)
{
for (i = 0; i < attr->num_values; i ++)
if (attr->values[i].integer == IPP_OP_CLOSE_JOB)
{
request = ippNewRequest(IPP_OP_CLOSE_JOB);
break;
}
}
if (!request)
request = ippNewRequest(IPP_OP_SEND_DOCUMENT);
if (!request)
{
_cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(ENOMEM), 0);
DEBUG_puts("1cupsCloseDestJob: Unable to create Close-Job/Send-Document "
"request.");
return (IPP_STATUS_ERROR_INTERNAL);
}
ippSetVersion(request, info->version / 10, info->version % 10);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
NULL, info->uri);
ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id",
job_id);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
NULL, cupsUser());
if (ippGetOperation(request) == IPP_OP_SEND_DOCUMENT)
ippAddBoolean(request, IPP_TAG_OPERATION, "last-document", 1);
/*
* Send the request and return the status...
*/
ippDelete(cupsDoRequest(http, request, info->resource));
DEBUG_printf(("1cupsCloseDestJob: %s (%s)", ippErrorString(cupsLastError()),
cupsLastErrorString()));
return (cupsLastError());
}
int /* O - Number of jobs */
cupsGetJobs2(http_t *http, /* I - HTTP connection */
cups_job_t **jobs, /* O - Job data */
const char *mydest, /* I - NULL = all destinations, *
* otherwise show jobs for mydest */
int myjobs, /* I - 0 = all users, 1 = mine */
int completed) /* I - -1 = show all, 0 = active, *
* 1 = completed jobs */
{
int n; /* Number of jobs */
ipp_t *request, /* IPP Request */
*response; /* IPP Response */
ipp_attribute_t *attr; /* Current attribute */
cups_job_t *temp; /* Temporary pointer */
int id, /* job-id */
priority, /* job-priority */
size; /* job-k-octets */
ipp_jstate_t state; /* job-state */
time_t completed_time, /* time-at-completed */
creation_time, /* time-at-creation */
processing_time; /* time-at-processing */
const char *dest, /* job-printer-uri */
*format, /* document-format */
*title, /* job-name */
*user; /* job-originating-user-name */
char uri[HTTP_MAX_URI]; /* URI for jobs */
_cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
static const char * const attrs[] = /* Requested attributes */
{
"job-id",
"job-priority",
"job-k-octets",
"job-state",
"time-at-completed",
"time-at-creation",
"time-at-processing",
"job-printer-uri",
"document-format",
"job-name",
"job-originating-user-name"
};
/*
* Range check input...
*/
if (!http || !jobs)
{
_cupsSetError(IPP_INTERNAL_ERROR, NULL);
return (-1);
}
/*
* Get the right URI...
*/
if (mydest)
{
if (httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
"localhost", 0, "/printers/%s", mydest) != HTTP_URI_OK)
{
_cupsSetError(IPP_INTERNAL_ERROR, NULL);
return (-1);
}
}
else
strcpy(uri, "ipp://localhost/jobs");
/*
* Build an IPP_GET_JOBS request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
* requesting-user-name
* which-jobs
* my-jobs
* requested-attributes
*/
request = ippNewRequest(IPP_GET_JOBS);
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());
if (myjobs)
ippAddBoolean(request, IPP_TAG_OPERATION, "my-jobs", 1);
if (completed > 0)
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
"which-jobs", NULL, "completed");
else if (completed < 0)
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
"which-jobs", NULL, "all");
ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
"requested-attributes", sizeof(attrs) / sizeof(attrs[0]),
NULL, attrs);
/*
* Do the request and get back a response...
*/
n = 0;
*jobs = NULL;
if ((response = cupsDoRequest(http, request, "/")) != NULL)
{
for (attr = response->attrs; attr != NULL; attr = attr->next)
{
/*
* Skip leading attributes until we hit a job...
*/
while (attr != NULL && attr->group_tag != IPP_TAG_JOB)
attr = attr->next;
if (attr == NULL)
break;
/*
* Pull the needed attributes from this job...
*/
id = 0;
size = 0;
priority = 50;
state = IPP_JOB_PENDING;
user = "******";
dest = NULL;
format = "application/octet-stream";
title = "untitled";
creation_time = 0;
completed_time = 0;
processing_time = 0;
while (attr != NULL && attr->group_tag == IPP_TAG_JOB)
{
if (strcmp(attr->name, "job-id") == 0 &&
attr->value_tag == IPP_TAG_INTEGER)
id = attr->values[0].integer;
else if (strcmp(attr->name, "job-state") == 0 &&
attr->value_tag == IPP_TAG_ENUM)
state = (ipp_jstate_t)attr->values[0].integer;
else if (strcmp(attr->name, "job-priority") == 0 &&
attr->value_tag == IPP_TAG_INTEGER)
priority = attr->values[0].integer;
else if (strcmp(attr->name, "job-k-octets") == 0 &&
attr->value_tag == IPP_TAG_INTEGER)
size = attr->values[0].integer;
else if (strcmp(attr->name, "time-at-completed") == 0 &&
attr->value_tag == IPP_TAG_INTEGER)
completed_time = attr->values[0].integer;
else if (strcmp(attr->name, "time-at-creation") == 0 &&
attr->value_tag == IPP_TAG_INTEGER)
creation_time = attr->values[0].integer;
else if (strcmp(attr->name, "time-at-processing") == 0 &&
attr->value_tag == IPP_TAG_INTEGER)
processing_time = attr->values[0].integer;
else if (strcmp(attr->name, "job-printer-uri") == 0 &&
attr->value_tag == IPP_TAG_URI)
{
if ((dest = strrchr(attr->values[0].string.text, '/')) != NULL)
dest ++;
}
else if (strcmp(attr->name, "job-originating-user-name") == 0 &&
attr->value_tag == IPP_TAG_NAME)
user = attr->values[0].string.text;
else if (strcmp(attr->name, "document-format") == 0 &&
attr->value_tag == IPP_TAG_MIMETYPE)
format = attr->values[0].string.text;
else if (strcmp(attr->name, "job-name") == 0 &&
(attr->value_tag == IPP_TAG_TEXT ||
attr->value_tag == IPP_TAG_NAME))
title = attr->values[0].string.text;
attr = attr->next;
}
/*
* See if we have everything needed...
*/
if (dest == NULL || id == 0)
{
if (attr == NULL)
break;
else
continue;
}
/*
* Allocate memory for the job...
*/
if (n == 0)
temp = malloc(sizeof(cups_job_t));
else
temp = realloc(*jobs, sizeof(cups_job_t) * (n + 1));
if (temp == NULL)
{
/*
* Ran out of memory!
*/
cupsFreeJobs(n, *jobs);
*jobs = NULL;
ippDelete(response);
return (0);
}
*jobs = temp;
temp += n;
n ++;
/*
* Copy the data over...
*/
temp->dest = strdup(dest);
temp->user = strdup(user);
temp->format = strdup(format);
temp->title = strdup(title);
temp->id = id;
temp->priority = priority;
temp->state = state;
temp->size = size;
temp->completed_time = completed_time;
temp->creation_time = creation_time;
temp->processing_time = processing_time;
if (attr == NULL)
break;
}
ippDelete(response);
}
if (n == 0 && cg->last_error >= IPP_BAD_REQUEST)
return (-1);
else
return (n);
}