[thirdparty/cups.git] / backend / socket.c

/*
 * AppSocket backend for CUPS.
 *
 * Copyright © 2020-2024 by OpenPrinting.
 * 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 */
  struct sigaction action;		/* Actions for POSIX signals */


 /*
  * Make sure status messages are not buffered...
  */

  setbuf(stderr, NULL);

 /*
  * Ignore SIGPIPE signals...
  */

  memset(&action, 0, sizeof(action));
  action.sa_handler = SIG_IGN;
  sigaction(SIGPIPE, &action, NULL);

 /*
  * 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);
}
Commit	Line	Data
	1	/*
	2	* AppSocket backend for CUPS.
	3	*
	4	* Copyright © 2020-2024 by OpenPrinting.
	5	* Copyright © 2007-2018 by Apple Inc.
	6	* Copyright © 1997-2007 by Easy Software Products, all rights reserved.
	7	*
	8	* Licensed under Apache License v2.0. See the file "LICENSE" for more
	9	* information.
	10	*/
	11
	12	/*
	13	* Include necessary headers.
	14	*/
	15
	16	#include <cups/http-private.h>
	17	#include "backend-private.h"
	18	#include <stdarg.h>
	19	#include <sys/types.h>
	20	#include <sys/stat.h>
	21
	22	#ifdef _WIN32
	23	# include <winsock.h>
	24	#else
	25	# include <unistd.h>
	26	# include <fcntl.h>
	27	# include <sys/socket.h>
	28	# include <netinet/in.h>
	29	# include <arpa/inet.h>
	30	# include <netdb.h>
	31	#endif /* _WIN32 */
	32
	33
	34	/*
	35	* Local functions...
	36	*/
	37
	38	static ssize_t wait_bc(int device_fd, int secs);
	39
	40
	41	/*
	42	* 'main()' - Send a file to the printer or server.
	43	*
	44	* Usage:
	45	*
	46	* printer-uri job-id user title copies options [file]
	47	*/
	48
	49	int /* O - Exit status */
	50	main(int argc, /* I - Number of command-line arguments (6 or 7) */
	51	char argv[]) / I - Command-line arguments */
	52	{
	53	const char device_uri; / Device URI */
	54	char scheme[255], /* Scheme in URI */
	55	hostname[1024], /* Hostname */
	56	username[255], /* Username info (not used) */
	57	resource[1024], /* Resource info (not used) */
	58	options, / Pointer to options */
	59	name, / Name of option */
	60	value, / Value of option */
	61	sep; /* Option separator */
	62	int print_fd; /* Print file */
	63	int copies; /* Number of copies to print */
	64	time_t start_time; /* Time of first connect */
	65	int contimeout; /* Connection timeout */
	66	int waiteof; /* Wait for end-of-file? */
	67	int port; /* Port number */
	68	int delay; /* Delay for retries... */
	69	int device_fd; /* AppSocket */
	70	int error; /* Error code (if any) */
	71	http_addrlist_t addrlist, / Address list */
	72	addr; / Connected address */
	73	char addrname[256]; /* Address name */
	74	int snmp_enabled = 1; /* Is SNMP enabled? */
	75	int snmp_fd, /* SNMP socket */
	76	start_count, /* Page count via SNMP at start */
	77	page_count, /* Page count via SNMP */
	78	have_supplies; /* Printer supports supply levels? */
	79	ssize_t bytes = 0, /* Initial bytes read */
	80	tbytes; /* Total number of bytes written */
	81	char buffer[1024]; /* Initial print buffer */
	82	struct sigaction action; /* Actions for POSIX signals */
	83
	84
	85	/*
	86	* Make sure status messages are not buffered...
	87	*/
	88
	89	setbuf(stderr, NULL);
	90
	91	/*
	92	* Ignore SIGPIPE signals...
	93	*/
	94
	95	memset(&action, 0, sizeof(action));
	96	action.sa_handler = SIG_IGN;
	97	sigaction(SIGPIPE, &action, NULL);
	98
	99	/*
	100	* Check command-line...
	101	*/
	102
	103	if (argc == 1)
	104	{
	105	printf("network socket \"Unknown\" \"%s\"\n",
	106	_cupsLangString(cupsLangDefault(), _("AppSocket/HP JetDirect")));
	107	return (CUPS_BACKEND_OK);
	108	}
	109	else if (argc != 6 && argc != 7)
	110	{
	111	_cupsLangPrintf(stderr,
	112	_("Usage: %s job-id user title copies options [file]"),
	113	argv[0]);
	114	return (CUPS_BACKEND_FAILED);
	115	}
	116
	117	/*
	118	* If we have 7 arguments, print the file named on the command-line.
	119	* Otherwise, send stdin instead...
	120	*/
	121
	122	if (argc == 6)
	123	{
	124	print_fd = 0;
	125	copies = 1;
	126	}
	127	else
	128	{
	129	/*
	130	* Try to open the print file...
	131	*/
	132
	133	if ((print_fd = open(argv[6], O_RDONLY)) < 0)
	134	{
	135	_cupsLangPrintError("ERROR", _("Unable to open print file"));
	136	return (CUPS_BACKEND_FAILED);
	137	}
	138
	139	copies = atoi(argv[4]);
	140	}
	141
	142	/*
	143	* Extract the hostname and port number from the URI...
	144	*/
	145
	146	while ((device_uri = cupsBackendDeviceURI(argv)) == NULL)
	147	{
	148	_cupsLangPrintFilter(stderr, "INFO", _("Unable to locate printer."));
	149	sleep(10);
	150
	151	if (getenv("CLASS") != NULL)
	152	return (CUPS_BACKEND_FAILED);
	153	}
	154
	155	httpSeparateURI(HTTP_URI_CODING_ALL, device_uri, scheme, sizeof(scheme),
	156	username, sizeof(username), hostname, sizeof(hostname), &port,
	157	resource, sizeof(resource));
	158
	159	if (port == 0)
	160	port = 9100; /* Default to HP JetDirect/Tektronix PhaserShare */
	161
	162	/*
	163	* Get options, if any...
	164	*/
	165
	166	waiteof = 1;
	167	contimeout = 7 * 24 * 60 * 60;
	168
	169	if ((options = strchr(resource, '?')) != NULL)
	170	{
	171	/*
	172	* Yup, terminate the device name string and move to the first
	173	* character of the options...
	174	*/
	175
	176	*options++ = '\0';
	177
	178	/*
	179	* Parse options...
	180	*/
	181
	182	while (*options)
	183	{
	184	/*
	185	* Get the name...
	186	*/
	187
	188	name = options;
	189
	190	while (options && options != '=' && options != '+' && options != '&')
	191	options ++;
	192
	193	if ((sep = *options) != '\0')
	194	*options++ = '\0';
	195
	196	if (sep == '=')
	197	{
	198	/*
	199	* Get the value...
	200	*/
	201
	202	value = options;
	203
	204	while (options && options != '+' && *options != '&')
	205	options ++;
	206
	207	if (*options)
	208	*options++ = '\0';
	209	}
	210	else
	211	value = (char *)"";
	212
	213	/*
	214	* Process the option...
	215	*/
	216
	217	if (!_cups_strcasecmp(name, "waiteof"))
	218	{
	219	/*
	220	* Set the wait-for-eof value...
	221	*/
	222
	223	waiteof = !value[0] \|\| !_cups_strcasecmp(value, "on") \|\|
	224	!_cups_strcasecmp(value, "yes") \|\| !_cups_strcasecmp(value, "true");
	225	}
	226	else if (!_cups_strcasecmp(name, "snmp"))
	227	{
	228	/*
	229	* Enable/disable SNMP stuff...
	230	*/
	231
	232	snmp_enabled = !value[0] \|\| !_cups_strcasecmp(value, "on") \|\|
	233	!_cups_strcasecmp(value, "yes") \|\|
	234	!_cups_strcasecmp(value, "true");
	235	}
	236	else if (!_cups_strcasecmp(name, "contimeout"))
	237	{
	238	/*
	239	* Set the connection timeout...
	240	*/
	241
	242	if (atoi(value) > 0)
	243	contimeout = atoi(value);
	244	}
	245	}
	246	}
	247
	248	/*
	249	* Then try finding the remote host...
	250	*/
	251
	252	start_time = time(NULL);
	253
	254	addrlist = backendLookup(hostname, port, NULL);
	255
	256	/*
	257	* See if the printer supports SNMP...
	258	*/
	259
	260	if (snmp_enabled)
	261	snmp_fd = _cupsSNMPOpen(addrlist->addr.addr.sa_family);
	262	else
	263	snmp_fd = -1;
	264
	265	if (snmp_fd >= 0)
	266	have_supplies = !backendSNMPSupplies(snmp_fd, &(addrlist->addr),
	267	&start_count, NULL);
	268	else
	269	have_supplies = start_count = 0;
	270
	271	/*
	272	* Wait for data from the filter...
	273	*/
	274
	275	if (print_fd == 0)
	276	{
	277	if (!backendWaitLoop(snmp_fd, &(addrlist->addr), 1, backendNetworkSideCB))
	278	return (CUPS_BACKEND_OK);
	279	else if ((bytes = read(0, buffer, sizeof(buffer))) <= 0)
	280	return (CUPS_BACKEND_OK);
	281	}
	282
	283	/*
	284	* Connect to the printer...
	285	*/
	286
	287	fprintf(stderr, "DEBUG: Connecting to %s:%d\n", hostname, port);
	288	_cupsLangPrintFilter(stderr, "INFO", _("Connecting to printer."));
	289
	290	for (delay = 5;;)
	291	{
	292	if ((addr = httpAddrConnect(addrlist, &device_fd)) == NULL)
	293	{
	294	error = errno;
	295	device_fd = -1;
	296
	297	if (getenv("CLASS") != NULL)
	298	{
	299	/*
	300	* If the CLASS environment variable is set, the job was submitted
	301	* to a class and not to a specific queue. In this case, we want
	302	* to abort immediately so that the job can be requeued on the next
	303	* available printer in the class.
	304	*/
	305
	306	_cupsLangPrintFilter(stderr, "INFO",
	307	_("Unable to contact printer, queuing on next "
	308	"printer in class."));
	309
	310	/*
	311	* Sleep 5 seconds to keep the job from requeuing too rapidly...
	312	*/
	313
	314	sleep(5);
	315
	316	return (CUPS_BACKEND_FAILED);
	317	}
	318
	319	fprintf(stderr, "DEBUG: Connection error: %s\n", strerror(error));
	320
	321	if (errno == ECONNREFUSED \|\| errno == EHOSTDOWN \|\| errno == EHOSTUNREACH \|\| errno == ETIMEDOUT \|\| errno == ENOTCONN)
	322	{
	323	if (contimeout && (time(NULL) - start_time) > contimeout)
	324	{
	325	_cupsLangPrintFilter(stderr, "ERROR",
	326	_("The printer is not responding."));
	327	return (CUPS_BACKEND_FAILED);
	328	}
	329
	330	switch (error)
	331	{
	332	case EHOSTDOWN :
	333	_cupsLangPrintFilter(stderr, "WARNING",
	334	_("The printer may not exist or "
	335	"is unavailable at this time."));
	336	break;
	337
	338	case EHOSTUNREACH :
	339	default :
	340	_cupsLangPrintFilter(stderr, "WARNING",
	341	_("The printer is unreachable at this "
	342	"time."));
	343	break;
	344
	345	case ECONNREFUSED :
	346	_cupsLangPrintFilter(stderr, "WARNING",
	347	_("The printer is in use."));
	348	break;
	349	}
	350
	351	sleep((unsigned)delay);
	352
	353	if (delay < 30)
	354	delay += 5;
	355	}
	356	else
	357	{
	358	_cupsLangPrintFilter(stderr, "ERROR",
	359	_("The printer is not responding."));
	360	sleep(30);
	361	}
	362	}
	363	else
	364	break;
	365	}
	366
	367	fputs("STATE: -connecting-to-device\n", stderr);
	368	_cupsLangPrintFilter(stderr, "INFO", _("Connected to printer."));
	369
	370	fprintf(stderr, "DEBUG: Connected to %s:%d...\n",
	371	httpAddrString(&(addr->addr), addrname, sizeof(addrname)),
	372	httpAddrPort(&(addr->addr)));
	373
	374	/*
	375	* Print everything...
	376	*/
	377
	378	tbytes = 0;
	379
	380	if (bytes > 0)
	381	tbytes += write(device_fd, buffer, (size_t)bytes);
	382
	383	while (copies > 0 && tbytes >= 0)
	384	{
	385	copies --;
	386
	387	if (print_fd != 0)
	388	{
	389	fputs("PAGE: 1 1\n", stderr);
	390	lseek(print_fd, 0, SEEK_SET);
	391	}
	392
	393	if ((bytes = backendRunLoop(print_fd, device_fd, snmp_fd, &(addrlist->addr), 1, 0, backendNetworkSideCB)) < 0)
	394	tbytes = -1;
	395	else
	396	tbytes = bytes;
	397
	398	if (print_fd != 0 && tbytes >= 0)
	399	_cupsLangPrintFilter(stderr, "INFO", _("Print file sent."));
	400	}
	401
	402	fputs("STATE: +cups-waiting-for-job-completed\n", stderr);
	403
	404	if (waiteof && tbytes >= 0)
	405	{
	406	/*
	407	* Shutdown the socket and wait for the other end to finish...
	408	*/
	409
	410	_cupsLangPrintFilter(stderr, "INFO", _("Waiting for printer to finish."));
	411
	412	shutdown(device_fd, 1);
	413
	414	while (wait_bc(device_fd, 90) > 0);
	415	}
	416
	417	/*
	418	* Collect the final page count as needed...
	419	*/
	420
	421	if (have_supplies &&
	422	!backendSNMPSupplies(snmp_fd, &(addrlist->addr), &page_count, NULL) &&
	423	page_count > start_count)
	424	fprintf(stderr, "PAGE: total %d\n", page_count - start_count);
	425
	426	/*
	427	* Close the socket connection...
	428	*/
	429
	430	close(device_fd);
	431
	432	httpAddrFreeList(addrlist);
	433
	434	/*
	435	* Close the input file and return...
	436	*/
	437
	438	if (print_fd != 0)
	439	close(print_fd);
	440
	441	return (tbytes >= 0 ? CUPS_BACKEND_OK : CUPS_BACKEND_FAILED);
	442	}
	443
	444
	445	/*
	446	* 'wait_bc()' - Wait for back-channel data...
	447	*/
	448
	449	static ssize_t /* O - # bytes read or -1 on error */
	450	wait_bc(int device_fd, /* I - Socket */
	451	int secs) /* I - Seconds to wait */
	452	{
	453	struct timeval timeout; /* Timeout for select() */
	454	fd_set input; /* Input set for select() */
	455	ssize_t bytes; /* Number of back-channel bytes read */
	456	char buffer[1024]; /* Back-channel buffer */
	457
	458
	459	/*
	460	* Wait up to "secs" seconds for backchannel data...
	461	*/
	462
	463	timeout.tv_sec = secs;
	464	timeout.tv_usec = 0;
	465
	466	FD_ZERO(&input);
	467	FD_SET(device_fd, &input);
	468
	469	if (select(device_fd + 1, &input, NULL, NULL, &timeout) > 0)
	470	{
	471	/*
	472	* Grab the data coming back and spit it out to stderr...
	473	*/
	474
	475	if ((bytes = read(device_fd, buffer, sizeof(buffer))) > 0)
	476	{
	477	fprintf(stderr, "DEBUG: Received %d bytes of back-channel data\n",
	478	(int)bytes);
	479	cupsBackChannelWrite(buffer, (size_t)bytes, 1.0);
	480	}
	481
	482	return (bytes);
	483	}
	484	else
	485	return (-1);
	486	}