mirror of https://gitee.com/openkylin/cups.git
494 lines
11 KiB
C
494 lines
11 KiB
C
/*
|
||
* AppSocket backend for CUPS.
|
||
*
|
||
* Copyright © 2007-2018 by Apple Inc.
|
||
* Copyright © 1997-2007 by Easy Software Products, all rights reserved.
|
||
*
|
||
* Licensed under Apache License v2.0. See the file "LICENSE" for more
|
||
* information.
|
||
*/
|
||
|
||
/*
|
||
* Include necessary headers.
|
||
*/
|
||
|
||
#include <cups/http-private.h>
|
||
#include "backend-private.h"
|
||
#include <stdarg.h>
|
||
#include <sys/types.h>
|
||
#include <sys/stat.h>
|
||
|
||
#ifdef _WIN32
|
||
# include <winsock.h>
|
||
#else
|
||
# include <unistd.h>
|
||
# include <fcntl.h>
|
||
# include <sys/socket.h>
|
||
# include <netinet/in.h>
|
||
# include <arpa/inet.h>
|
||
# include <netdb.h>
|
||
#endif /* _WIN32 */
|
||
|
||
|
||
/*
|
||
* Local functions...
|
||
*/
|
||
|
||
static ssize_t wait_bc(int device_fd, int secs);
|
||
|
||
|
||
/*
|
||
* 'main()' - Send a file to the printer or server.
|
||
*
|
||
* Usage:
|
||
*
|
||
* printer-uri job-id user title copies options [file]
|
||
*/
|
||
|
||
int /* O - Exit status */
|
||
main(int argc, /* I - Number of command-line arguments (6 or 7) */
|
||
char *argv[]) /* I - Command-line arguments */
|
||
{
|
||
const char *device_uri; /* Device URI */
|
||
char scheme[255], /* Scheme in URI */
|
||
hostname[1024], /* Hostname */
|
||
username[255], /* Username info (not used) */
|
||
resource[1024], /* Resource info (not used) */
|
||
*options, /* Pointer to options */
|
||
*name, /* Name of option */
|
||
*value, /* Value of option */
|
||
sep; /* Option separator */
|
||
int print_fd; /* Print file */
|
||
int copies; /* Number of copies to print */
|
||
time_t start_time; /* Time of first connect */
|
||
int contimeout; /* Connection timeout */
|
||
int waiteof; /* Wait for end-of-file? */
|
||
int port; /* Port number */
|
||
int delay; /* Delay for retries... */
|
||
int device_fd; /* AppSocket */
|
||
int error; /* Error code (if any) */
|
||
http_addrlist_t *addrlist, /* Address list */
|
||
*addr; /* Connected address */
|
||
char addrname[256]; /* Address name */
|
||
int snmp_enabled = 1; /* Is SNMP enabled? */
|
||
int snmp_fd, /* SNMP socket */
|
||
start_count, /* Page count via SNMP at start */
|
||
page_count, /* Page count via SNMP */
|
||
have_supplies; /* Printer supports supply levels? */
|
||
ssize_t bytes = 0, /* Initial bytes read */
|
||
tbytes; /* Total number of bytes written */
|
||
char buffer[1024]; /* Initial print buffer */
|
||
#if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)
|
||
struct sigaction action; /* Actions for POSIX signals */
|
||
#endif /* HAVE_SIGACTION && !HAVE_SIGSET */
|
||
|
||
|
||
/*
|
||
* Make sure status messages are not buffered...
|
||
*/
|
||
|
||
setbuf(stderr, NULL);
|
||
|
||
/*
|
||
* Ignore SIGPIPE signals...
|
||
*/
|
||
|
||
#ifdef HAVE_SIGSET
|
||
sigset(SIGPIPE, SIG_IGN);
|
||
#elif defined(HAVE_SIGACTION)
|
||
memset(&action, 0, sizeof(action));
|
||
action.sa_handler = SIG_IGN;
|
||
sigaction(SIGPIPE, &action, NULL);
|
||
#else
|
||
signal(SIGPIPE, SIG_IGN);
|
||
#endif /* HAVE_SIGSET */
|
||
|
||
/*
|
||
* Check command-line...
|
||
*/
|
||
|
||
if (argc == 1)
|
||
{
|
||
printf("network socket \"Unknown\" \"%s\"\n",
|
||
_cupsLangString(cupsLangDefault(), _("AppSocket/HP JetDirect")));
|
||
return (CUPS_BACKEND_OK);
|
||
}
|
||
else if (argc != 6 && argc != 7)
|
||
{
|
||
_cupsLangPrintf(stderr,
|
||
_("Usage: %s job-id user title copies options [file]"),
|
||
argv[0]);
|
||
return (CUPS_BACKEND_FAILED);
|
||
}
|
||
|
||
/*
|
||
* If we have 7 arguments, print the file named on the command-line.
|
||
* Otherwise, send stdin instead...
|
||
*/
|
||
|
||
if (argc == 6)
|
||
{
|
||
print_fd = 0;
|
||
copies = 1;
|
||
}
|
||
else
|
||
{
|
||
/*
|
||
* Try to open the print file...
|
||
*/
|
||
|
||
if ((print_fd = open(argv[6], O_RDONLY)) < 0)
|
||
{
|
||
_cupsLangPrintError("ERROR", _("Unable to open print file"));
|
||
return (CUPS_BACKEND_FAILED);
|
||
}
|
||
|
||
copies = atoi(argv[4]);
|
||
}
|
||
|
||
/*
|
||
* Extract the hostname and port number from the URI...
|
||
*/
|
||
|
||
while ((device_uri = cupsBackendDeviceURI(argv)) == NULL)
|
||
{
|
||
_cupsLangPrintFilter(stderr, "INFO", _("Unable to locate printer."));
|
||
sleep(10);
|
||
|
||
if (getenv("CLASS") != NULL)
|
||
return (CUPS_BACKEND_FAILED);
|
||
}
|
||
|
||
httpSeparateURI(HTTP_URI_CODING_ALL, device_uri, scheme, sizeof(scheme),
|
||
username, sizeof(username), hostname, sizeof(hostname), &port,
|
||
resource, sizeof(resource));
|
||
|
||
if (port == 0)
|
||
port = 9100; /* Default to HP JetDirect/Tektronix PhaserShare */
|
||
|
||
/*
|
||
* Get options, if any...
|
||
*/
|
||
|
||
waiteof = 1;
|
||
contimeout = 7 * 24 * 60 * 60;
|
||
|
||
if ((options = strchr(resource, '?')) != NULL)
|
||
{
|
||
/*
|
||
* Yup, terminate the device name string and move to the first
|
||
* character of the options...
|
||
*/
|
||
|
||
*options++ = '\0';
|
||
|
||
/*
|
||
* Parse options...
|
||
*/
|
||
|
||
while (*options)
|
||
{
|
||
/*
|
||
* Get the name...
|
||
*/
|
||
|
||
name = options;
|
||
|
||
while (*options && *options != '=' && *options != '+' && *options != '&')
|
||
options ++;
|
||
|
||
if ((sep = *options) != '\0')
|
||
*options++ = '\0';
|
||
|
||
if (sep == '=')
|
||
{
|
||
/*
|
||
* Get the value...
|
||
*/
|
||
|
||
value = options;
|
||
|
||
while (*options && *options != '+' && *options != '&')
|
||
options ++;
|
||
|
||
if (*options)
|
||
*options++ = '\0';
|
||
}
|
||
else
|
||
value = (char *)"";
|
||
|
||
/*
|
||
* Process the option...
|
||
*/
|
||
|
||
if (!_cups_strcasecmp(name, "waiteof"))
|
||
{
|
||
/*
|
||
* Set the wait-for-eof value...
|
||
*/
|
||
|
||
waiteof = !value[0] || !_cups_strcasecmp(value, "on") ||
|
||
!_cups_strcasecmp(value, "yes") || !_cups_strcasecmp(value, "true");
|
||
}
|
||
else if (!_cups_strcasecmp(name, "snmp"))
|
||
{
|
||
/*
|
||
* Enable/disable SNMP stuff...
|
||
*/
|
||
|
||
snmp_enabled = !value[0] || !_cups_strcasecmp(value, "on") ||
|
||
!_cups_strcasecmp(value, "yes") ||
|
||
!_cups_strcasecmp(value, "true");
|
||
}
|
||
else if (!_cups_strcasecmp(name, "contimeout"))
|
||
{
|
||
/*
|
||
* Set the connection timeout...
|
||
*/
|
||
|
||
if (atoi(value) > 0)
|
||
contimeout = atoi(value);
|
||
}
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Then try finding the remote host...
|
||
*/
|
||
|
||
start_time = time(NULL);
|
||
|
||
addrlist = backendLookup(hostname, port, NULL);
|
||
|
||
/*
|
||
* See if the printer supports SNMP...
|
||
*/
|
||
|
||
if (snmp_enabled)
|
||
snmp_fd = _cupsSNMPOpen(addrlist->addr.addr.sa_family);
|
||
else
|
||
snmp_fd = -1;
|
||
|
||
if (snmp_fd >= 0)
|
||
have_supplies = !backendSNMPSupplies(snmp_fd, &(addrlist->addr),
|
||
&start_count, NULL);
|
||
else
|
||
have_supplies = start_count = 0;
|
||
|
||
/*
|
||
* Wait for data from the filter...
|
||
*/
|
||
|
||
if (print_fd == 0)
|
||
{
|
||
if (!backendWaitLoop(snmp_fd, &(addrlist->addr), 1, backendNetworkSideCB))
|
||
return (CUPS_BACKEND_OK);
|
||
else if ((bytes = read(0, buffer, sizeof(buffer))) <= 0)
|
||
return (CUPS_BACKEND_OK);
|
||
}
|
||
|
||
/*
|
||
* Connect to the printer...
|
||
*/
|
||
|
||
fprintf(stderr, "DEBUG: Connecting to %s:%d\n", hostname, port);
|
||
_cupsLangPrintFilter(stderr, "INFO", _("Connecting to printer."));
|
||
|
||
for (delay = 5;;)
|
||
{
|
||
if ((addr = httpAddrConnect(addrlist, &device_fd)) == NULL)
|
||
{
|
||
error = errno;
|
||
device_fd = -1;
|
||
|
||
if (getenv("CLASS") != NULL)
|
||
{
|
||
/*
|
||
* If the CLASS environment variable is set, the job was submitted
|
||
* to a class and not to a specific queue. In this case, we want
|
||
* to abort immediately so that the job can be requeued on the next
|
||
* available printer in the class.
|
||
*/
|
||
|
||
_cupsLangPrintFilter(stderr, "INFO",
|
||
_("Unable to contact printer, queuing on next "
|
||
"printer in class."));
|
||
|
||
/*
|
||
* Sleep 5 seconds to keep the job from requeuing too rapidly...
|
||
*/
|
||
|
||
sleep(5);
|
||
|
||
return (CUPS_BACKEND_FAILED);
|
||
}
|
||
|
||
fprintf(stderr, "DEBUG: Connection error: %s\n", strerror(error));
|
||
|
||
if (errno == ECONNREFUSED || errno == EHOSTDOWN || errno == EHOSTUNREACH || errno == ETIMEDOUT || errno == ENOTCONN)
|
||
{
|
||
if (contimeout && (time(NULL) - start_time) > contimeout)
|
||
{
|
||
_cupsLangPrintFilter(stderr, "ERROR",
|
||
_("The printer is not responding."));
|
||
return (CUPS_BACKEND_FAILED);
|
||
}
|
||
|
||
switch (error)
|
||
{
|
||
case EHOSTDOWN :
|
||
_cupsLangPrintFilter(stderr, "WARNING",
|
||
_("The printer may not exist or "
|
||
"is unavailable at this time."));
|
||
break;
|
||
|
||
case EHOSTUNREACH :
|
||
default :
|
||
_cupsLangPrintFilter(stderr, "WARNING",
|
||
_("The printer is unreachable at this "
|
||
"time."));
|
||
break;
|
||
|
||
case ECONNREFUSED :
|
||
_cupsLangPrintFilter(stderr, "WARNING",
|
||
_("The printer is in use."));
|
||
break;
|
||
}
|
||
|
||
sleep((unsigned)delay);
|
||
|
||
if (delay < 30)
|
||
delay += 5;
|
||
}
|
||
else
|
||
{
|
||
_cupsLangPrintFilter(stderr, "ERROR",
|
||
_("The printer is not responding."));
|
||
sleep(30);
|
||
}
|
||
}
|
||
else
|
||
break;
|
||
}
|
||
|
||
fputs("STATE: -connecting-to-device\n", stderr);
|
||
_cupsLangPrintFilter(stderr, "INFO", _("Connected to printer."));
|
||
|
||
fprintf(stderr, "DEBUG: Connected to %s:%d...\n",
|
||
httpAddrString(&(addr->addr), addrname, sizeof(addrname)),
|
||
httpAddrPort(&(addr->addr)));
|
||
|
||
/*
|
||
* Print everything...
|
||
*/
|
||
|
||
tbytes = 0;
|
||
|
||
if (bytes > 0)
|
||
tbytes += write(device_fd, buffer, (size_t)bytes);
|
||
|
||
while (copies > 0 && tbytes >= 0)
|
||
{
|
||
copies --;
|
||
|
||
if (print_fd != 0)
|
||
{
|
||
fputs("PAGE: 1 1\n", stderr);
|
||
lseek(print_fd, 0, SEEK_SET);
|
||
}
|
||
|
||
if ((bytes = backendRunLoop(print_fd, device_fd, snmp_fd, &(addrlist->addr), 1, 0, backendNetworkSideCB)) < 0)
|
||
tbytes = -1;
|
||
else
|
||
tbytes = bytes;
|
||
|
||
if (print_fd != 0 && tbytes >= 0)
|
||
_cupsLangPrintFilter(stderr, "INFO", _("Print file sent."));
|
||
}
|
||
|
||
fputs("STATE: +cups-waiting-for-job-completed\n", stderr);
|
||
|
||
if (waiteof && tbytes >= 0)
|
||
{
|
||
/*
|
||
* Shutdown the socket and wait for the other end to finish...
|
||
*/
|
||
|
||
_cupsLangPrintFilter(stderr, "INFO", _("Waiting for printer to finish."));
|
||
|
||
shutdown(device_fd, 1);
|
||
|
||
while (wait_bc(device_fd, 90) > 0);
|
||
}
|
||
|
||
/*
|
||
* Collect the final page count as needed...
|
||
*/
|
||
|
||
if (have_supplies &&
|
||
!backendSNMPSupplies(snmp_fd, &(addrlist->addr), &page_count, NULL) &&
|
||
page_count > start_count)
|
||
fprintf(stderr, "PAGE: total %d\n", page_count - start_count);
|
||
|
||
/*
|
||
* Close the socket connection...
|
||
*/
|
||
|
||
close(device_fd);
|
||
|
||
httpAddrFreeList(addrlist);
|
||
|
||
/*
|
||
* Close the input file and return...
|
||
*/
|
||
|
||
if (print_fd != 0)
|
||
close(print_fd);
|
||
|
||
return (tbytes >= 0 ? CUPS_BACKEND_OK : CUPS_BACKEND_FAILED);
|
||
}
|
||
|
||
|
||
/*
|
||
* 'wait_bc()' - Wait for back-channel data...
|
||
*/
|
||
|
||
static ssize_t /* O - # bytes read or -1 on error */
|
||
wait_bc(int device_fd, /* I - Socket */
|
||
int secs) /* I - Seconds to wait */
|
||
{
|
||
struct timeval timeout; /* Timeout for select() */
|
||
fd_set input; /* Input set for select() */
|
||
ssize_t bytes; /* Number of back-channel bytes read */
|
||
char buffer[1024]; /* Back-channel buffer */
|
||
|
||
|
||
/*
|
||
* Wait up to "secs" seconds for backchannel data...
|
||
*/
|
||
|
||
timeout.tv_sec = secs;
|
||
timeout.tv_usec = 0;
|
||
|
||
FD_ZERO(&input);
|
||
FD_SET(device_fd, &input);
|
||
|
||
if (select(device_fd + 1, &input, NULL, NULL, &timeout) > 0)
|
||
{
|
||
/*
|
||
* Grab the data coming back and spit it out to stderr...
|
||
*/
|
||
|
||
if ((bytes = read(device_fd, buffer, sizeof(buffer))) > 0)
|
||
{
|
||
fprintf(stderr, "DEBUG: Received %d bytes of back-channel data\n",
|
||
(int)bytes);
|
||
cupsBackChannelWrite(buffer, (size_t)bytes, 1.0);
|
||
}
|
||
|
||
return (bytes);
|
||
}
|
||
else
|
||
return (-1);
|
||
}
|