backend/lpd.c

   1 /*
   2  * "$Id: lpd.c 7740 2008-07-14 23:58:05Z mike $"
   3  *
   4  *   Line Printer Daemon backend for CUPS.
   5  *
   6  *   Copyright 2007-2012 by Apple Inc.
   7  *   Copyright 1997-2007 by Easy Software Products, all rights reserved.
   8  *
   9  *   These coded instructions, statements, and computer programs are the
  10  *   property of Apple Inc. and are protected by Federal copyright
  11  *   law.  Distribution and use rights are outlined in the file "LICENSE.txt"
  12  *   "LICENSE" which should have been included with this file.  If this
  13  *   file is missing or damaged, see the license at "http://www.cups.org/".
  14  *
  15  *   This file is subject to the Apple OS-Developed Software exception.
  16  *
  17  * Contents:
  18  *
  19  *   main()            - Send a file to the printer or server.
  20  *   lpd_command()     - Send an LPR command sequence and wait for a reply.
  21  *   lpd_queue()       - Queue a file using the Line Printer Daemon protocol.
  22  *   lpd_write()       - Write a buffer of data to an LPD server.
  23  *   rresvport_af()    - A simple implementation of rresvport_af().
  24  *   sigterm_handler() - Handle 'terminate' signals that stop the backend.
  25  */
  26
  27 /*
  28  * Include necessary headers.
  29  */
  30
  31 #include <cups/http-private.h>
  32 #include "backend-private.h"
  33 #include <stdarg.h>
  34 #include <sys/types.h>
  35 #include <sys/stat.h>
  36 #include <stdio.h>
  37
  38 #ifdef WIN32
  39 #  include <winsock.h>
  40 #else
  41 #  include <sys/socket.h>
  42 #  include <netinet/in.h>
  43 #  include <arpa/inet.h>
  44 #  include <netdb.h>
  45 #endif /* WIN32 */
  46 #ifdef __APPLE__
  47 #  include <CoreFoundation/CFNumber.h>
  48 #  include <CoreFoundation/CFPreferences.h>
  49 #endif /* __APPLE__ */
  50
  51
  52 /*
  53  * Globals...
  54  */
  55
  56 static char     tmpfilename[1024] = ""; /* Temporary spool file name */
  57 static int      abort_job = 0;          /* Non-zero if we get SIGTERM */
  58
  59
  60 /*
  61  * Print mode...
  62  */
  63
  64 #define MODE_STANDARD           0       /* Queue a copy */
  65 #define MODE_STREAM             1       /* Stream a copy */
  66
  67
  68 /*
  69  * The order for control and data files in LPD requests...
  70  */
  71
  72 #define ORDER_CONTROL_DATA      0       /* Control file first, then data */
  73 #define ORDER_DATA_CONTROL      1       /* Data file first, then control */
  74
  75
  76 /*
  77  * What to reserve...
  78  */
  79
  80 #define RESERVE_NONE            0       /* Don't reserve a priviledged port */
  81 #define RESERVE_RFC1179         1       /* Reserve port 721-731 */
  82 #define RESERVE_ANY             2       /* Reserve port 1-1023 */
  83
  84
  85 /*
  86  * Local functions...
  87  */
  88
  89 static int      lpd_command(int lpd_fd, char *format, ...);
  90 static int      lpd_queue(const char *hostname, http_addrlist_t *addrlist,
  91                           const char *printer, int print_fd, int snmp_fd,
  92                           int mode, const char *user, const char *title,
  93                           int copies, int banner, int format, int order,
  94                           int reserve, int manual_copies, int timeout,
  95                           int contimeout, const char *orighost);
  96 static int      lpd_write(int lpd_fd, char *buffer, int length);
  97 #ifndef HAVE_RRESVPORT_AF
  98 static int      rresvport_af(int *port, int family);
  99 #endif /* !HAVE_RRESVPORT_AF */
 100 static void     sigterm_handler(int sig);
 101
 102
 103 /*
 104  * 'main()' - Send a file to the printer or server.
 105  *
 106  * Usage:
 107  *
 108  *    printer-uri job-id user title copies options [file]
 109  */
 110
 111 int                                     /* O - Exit status */
 112 main(int  argc,                         /* I - Number of command-line arguments (6 or 7) */
 113      char *argv[])                      /* I - Command-line arguments */
 114 {
 115   const char    *device_uri;            /* Device URI */
 116   char          scheme[255],            /* Scheme in URI */
 117                 hostname[1024],         /* Hostname */
 118                 username[255],          /* Username info */
 119                 resource[1024],         /* Resource info (printer name) */
 120                 *options,               /* Pointer to options */
 121                 *name,                  /* Name of option */
 122                 *value,                 /* Value of option */
 123                 sep,                    /* Separator character */
 124                 *filename,              /* File to print */
 125                 title[256];             /* Title string */
 126   int           port;                   /* Port number */
 127   char          portname[256];          /* Port name (string) */
 128   http_addrlist_t *addrlist;            /* List of addresses for printer */
 129   int           snmp_fd;                /* SNMP socket */
 130   int           fd;                     /* Print file */
 131   int           status;                 /* Status of LPD job */
 132   int           mode;                   /* Print mode */
 133   int           banner;                 /* Print banner page? */
 134   int           format;                 /* Print format */
 135   int           order;                  /* Order of control/data files */
 136   int           reserve;                /* Reserve priviledged port? */
 137   int           sanitize_title;         /* Sanitize title string? */
 138   int           manual_copies,          /* Do manual copies? */
 139                 timeout,                /* Timeout */
 140                 contimeout,             /* Connection timeout */
 141                 copies;                 /* Number of copies */
 142   ssize_t       bytes = 0;              /* Initial bytes read */
 143   char          buffer[16384];          /* Initial print buffer */
 144 #if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)
 145   struct sigaction action;              /* Actions for POSIX signals */
 146 #endif /* HAVE_SIGACTION && !HAVE_SIGSET */
 147   int           num_jobopts;            /* Number of job options */
 148   cups_option_t *jobopts = NULL;        /* Job options */
 149
 150
 151  /*
 152   * Make sure status messages are not buffered...
 153   */
 154
 155   setbuf(stderr, NULL);
 156
 157  /*
 158   * Ignore SIGPIPE and catch SIGTERM signals...
 159   */
 160
 161 #ifdef HAVE_SIGSET
 162   sigset(SIGPIPE, SIG_IGN);
 163   sigset(SIGTERM, sigterm_handler);
 164 #elif defined(HAVE_SIGACTION)
 165   memset(&action, 0, sizeof(action));
 166   action.sa_handler = SIG_IGN;
 167   sigaction(SIGPIPE, &action, NULL);
 168
 169   sigemptyset(&action.sa_mask);
 170   sigaddset(&action.sa_mask, SIGTERM);
 171   action.sa_handler = sigterm_handler;
 172   sigaction(SIGTERM, &action, NULL);
 173 #else
 174   signal(SIGPIPE, SIG_IGN);
 175   signal(SIGTERM, sigterm_handler);
 176 #endif /* HAVE_SIGSET */
 177
 178  /*
 179   * Check command-line...
 180   */
 181
 182   if (argc == 1)
 183   {
 184     printf("network lpd \"Unknown\" \"%s\"\n",
 185            _cupsLangString(cupsLangDefault(), _("LPD/LPR Host or Printer")));
 186     return (CUPS_BACKEND_OK);
 187   }
 188   else if (argc < 6 || argc > 7)
 189   {
 190     _cupsLangPrintf(stderr,
 191                     _("Usage: %s job-id user title copies options [file]"),
 192                     argv[0]);
 193     return (CUPS_BACKEND_FAILED);
 194   }
 195
 196   num_jobopts = cupsParseOptions(argv[5], 0, &jobopts);
 197
 198  /*
 199   * Extract the hostname and printer name from the URI...
 200   */
 201
 202   while ((device_uri = cupsBackendDeviceURI(argv)) == NULL)
 203   {
 204     _cupsLangPrintFilter(stderr, "INFO", _("Unable to locate printer."));
 205     sleep(10);
 206
 207     if (getenv("CLASS") != NULL)
 208       return (CUPS_BACKEND_FAILED);
 209   }
 210
 211   httpSeparateURI(HTTP_URI_CODING_ALL, device_uri, scheme, sizeof(scheme),
 212                   username, sizeof(username), hostname, sizeof(hostname), &port,
 213                   resource, sizeof(resource));
 214
 215   if (!port)
 216     port = 515;                         /* Default to port 515 */
 217
 218   if (!username[0])
 219   {
 220    /*
 221     * If no username is in the device URI, then use the print job user...
 222     */
 223
 224     strlcpy(username, argv[2], sizeof(username));
 225   }
 226
 227  /*
 228   * See if there are any options...
 229   */
 230
 231   mode          = MODE_STANDARD;
 232   banner        = 0;
 233   format        = 'l';
 234   order         = ORDER_CONTROL_DATA;
 235   reserve       = RESERVE_ANY;
 236   manual_copies = 1;
 237   timeout       = 300;
 238   contimeout    = 7 * 24 * 60 * 60;
 239
 240 #ifdef __APPLE__
 241  /*
 242   * We want to pass UTF-8 characters by default, not re-map them (3071945)
 243   */
 244
 245   sanitize_title = 0;
 246 #else
 247  /*
 248   * Otherwise we want to re-map UTF-8 to "safe" characters by default...
 249   */
 250
 251   sanitize_title = 1;
 252 #endif /* __APPLE__ */
 253
 254   if ((options = strchr(resource, '?')) != NULL)
 255   {
 256    /*
 257     * Yup, terminate the device name string and move to the first
 258     * character of the options...
 259     */
 260
 261     *options++ = '\0';
 262
 263    /*
 264     * Parse options...
 265     */
 266
 267     while (*options)
 268     {
 269      /*
 270       * Get the name...
 271       */
 272
 273       name = options;
 274
 275       while (*options && *options != '=' && *options != '+' && *options != '&')
 276         options ++;
 277
 278       if ((sep = *options) != '\0')
 279         *options++ = '\0';
 280
 281       if (sep == '=')
 282       {
 283        /*
 284         * Get the value...
 285         */
 286
 287         value = options;
 288
 289         while (*options && *options != '+' && *options != '&')
 290           options ++;
 291
 292         if (*options)
 293           *options++ = '\0';
 294       }
 295       else
 296         value = (char *)"";
 297
 298      /*
 299       * Process the option...
 300       */
 301
 302       if (!_cups_strcasecmp(name, "banner"))
 303       {
 304        /*
 305         * Set the banner...
 306         */
 307
 308         banner = !value[0] || !_cups_strcasecmp(value, "on") ||
 309                  !_cups_strcasecmp(value, "yes") || !_cups_strcasecmp(value, "true");
 310       }
 311       else if (!_cups_strcasecmp(name, "format") && value[0])
 312       {
 313        /*
 314         * Set output format...
 315         */
 316
 317         if (strchr("cdfglnoprtv", value[0]))
 318           format = value[0];
 319         else
 320           _cupsLangPrintFilter(stderr, "ERROR",
 321                                _("Unknown format character: \"%c\"."),
 322                                value[0]);
 323       }
 324       else if (!_cups_strcasecmp(name, "mode") && value[0])
 325       {
 326        /*
 327         * Set control/data order...
 328         */
 329
 330         if (!_cups_strcasecmp(value, "standard"))
 331           mode = MODE_STANDARD;
 332         else if (!_cups_strcasecmp(value, "stream"))
 333           mode = MODE_STREAM;
 334         else
 335           _cupsLangPrintFilter(stderr, "ERROR",
 336                                _("Unknown print mode: \"%s\"."), value);
 337       }
 338       else if (!_cups_strcasecmp(name, "order") && value[0])
 339       {
 340        /*
 341         * Set control/data order...
 342         */
 343
 344         if (!_cups_strcasecmp(value, "control,data"))
 345           order = ORDER_CONTROL_DATA;
 346         else if (!_cups_strcasecmp(value, "data,control"))
 347           order = ORDER_DATA_CONTROL;
 348         else
 349           _cupsLangPrintFilter(stderr, "ERROR",
 350                                _("Unknown file order: \"%s\"."), value);
 351       }
 352       else if (!_cups_strcasecmp(name, "reserve"))
 353       {
 354        /*
 355         * Set port reservation mode...
 356         */
 357
 358         if (!value[0] || !_cups_strcasecmp(value, "on") ||
 359             !_cups_strcasecmp(value, "yes") || !_cups_strcasecmp(value, "true") ||
 360             !_cups_strcasecmp(value, "rfc1179"))
 361           reserve = RESERVE_RFC1179;
 362         else if (!_cups_strcasecmp(value, "any"))
 363           reserve = RESERVE_ANY;
 364         else
 365           reserve = RESERVE_NONE;
 366       }
 367       else if (!_cups_strcasecmp(name, "manual_copies"))
 368       {
 369        /*
 370         * Set manual copies...
 371         */
 372
 373         manual_copies = !value[0] || !_cups_strcasecmp(value, "on") ||
 374                         !_cups_strcasecmp(value, "yes") || !_cups_strcasecmp(value, "true");
 375       }
 376       else if (!_cups_strcasecmp(name, "sanitize_title"))
 377       {
 378        /*
 379         * Set sanitize title...
 380         */
 381
 382         sanitize_title = !value[0] || !_cups_strcasecmp(value, "on") ||
 383                          !_cups_strcasecmp(value, "yes") || !_cups_strcasecmp(value, "true");
 384       }
 385       else if (!_cups_strcasecmp(name, "timeout"))
 386       {
 387        /*
 388         * Set the timeout...
 389         */
 390
 391         if (atoi(value) > 0)
 392           timeout = atoi(value);
 393       }
 394       else if (!_cups_strcasecmp(name, "contimeout"))
 395       {
 396        /*
 397         * Set the connection timeout...
 398         */
 399
 400         if (atoi(value) > 0)
 401           contimeout = atoi(value);
 402       }
 403     }
 404   }
 405
 406   if (mode == MODE_STREAM)
 407     order = ORDER_CONTROL_DATA;
 408
 409  /*
 410   * Find the printer...
 411   */
 412
 413   snprintf(portname, sizeof(portname), "%d", port);
 414
 415   fputs("STATE: +connecting-to-device\n", stderr);
 416   fprintf(stderr, "DEBUG: Looking up \"%s\"...\n", hostname);
 417
 418   while ((addrlist = httpAddrGetList(hostname, AF_UNSPEC, portname)) == NULL)
 419   {
 420     _cupsLangPrintFilter(stderr, "INFO",
 421                          _("Unable to locate printer \"%s\"."), hostname);
 422     sleep(10);
 423
 424     if (getenv("CLASS") != NULL)
 425     {
 426       fputs("STATE: -connecting-to-device\n", stderr);
 427       exit(CUPS_BACKEND_FAILED);
 428     }
 429   }
 430
 431   snmp_fd = _cupsSNMPOpen(addrlist->addr.addr.sa_family);
 432
 433  /*
 434   * Wait for data from the filter...
 435   */
 436
 437   if (argc == 6)
 438   {
 439     if (!backendWaitLoop(snmp_fd, &(addrlist->addr), 0, backendNetworkSideCB))
 440       return (CUPS_BACKEND_OK);
 441     else if (mode == MODE_STANDARD &&
 442              (bytes = read(0, buffer, sizeof(buffer))) <= 0)
 443       return (CUPS_BACKEND_OK);
 444   }
 445
 446  /*
 447   * If we have 7 arguments, print the file named on the command-line.
 448   * Otherwise, copy stdin to a temporary file and print the temporary
 449   * file.
 450   */
 451
 452   if (argc == 6 && mode == MODE_STANDARD)
 453   {
 454    /*
 455     * Copy stdin to a temporary file...
 456     */
 457
 458     if ((fd = cupsTempFd(tmpfilename, sizeof(tmpfilename))) < 0)
 459     {
 460       perror("DEBUG: Unable to create temporary file");
 461       return (CUPS_BACKEND_FAILED);
 462     }
 463
 464     _cupsLangPrintFilter(stderr, "INFO", _("Copying print data."));
 465
 466     if (bytes > 0)
 467       write(fd, buffer, bytes);
 468
 469     backendRunLoop(-1, fd, snmp_fd, &(addrlist->addr), 0, 0,
 470                    backendNetworkSideCB);
 471   }
 472   else if (argc == 6)
 473   {
 474    /*
 475     * Stream from stdin...
 476     */
 477
 478     filename = NULL;
 479     fd       = 0;
 480   }
 481   else
 482   {
 483     filename = argv[6];
 484     fd       = open(filename, O_RDONLY);
 485
 486     if (fd == -1)
 487     {
 488       _cupsLangPrintError("ERROR", _("Unable to open print file"));
 489       return (CUPS_BACKEND_FAILED);
 490     }
 491   }
 492
 493  /*
 494   * Sanitize the document title...
 495   */
 496
 497   strlcpy(title, argv[3], sizeof(title));
 498
 499   if (sanitize_title)
 500   {
 501    /*
 502     * Sanitize the title string so that we don't cause problems on
 503     * the remote end...
 504     */
 505
 506     char *ptr;
 507
 508     for (ptr = title; *ptr; ptr ++)
 509       if (!isalnum(*ptr & 255) && !isspace(*ptr & 255))
 510         *ptr = '_';
 511   }
 512
 513  /*
 514   * Queue the job...
 515   */
 516
 517   if (argc > 6)
 518   {
 519     if (manual_copies)
 520     {
 521       manual_copies = atoi(argv[4]);
 522       copies        = 1;
 523     }
 524     else
 525     {
 526       manual_copies = 1;
 527       copies        = atoi(argv[4]);
 528     }
 529
 530     status = lpd_queue(hostname, addrlist, resource + 1, fd, snmp_fd, mode,
 531                        username, title, copies, banner, format, order, reserve,
 532                        manual_copies, timeout, contimeout,
 533                        cupsGetOption("job-originating-host-name", num_jobopts,
 534                                      jobopts));
 535
 536     if (!status)
 537       fprintf(stderr, "PAGE: 1 %d\n", atoi(argv[4]));
 538   }
 539   else
 540     status = lpd_queue(hostname, addrlist, resource + 1, fd, snmp_fd, mode,
 541                        username, title, 1, banner, format, order, reserve, 1,
 542                        timeout, contimeout,
 543                        cupsGetOption("job-originating-host-name", num_jobopts,
 544                                      jobopts));
 545
 546  /*
 547   * Remove the temporary file if necessary...
 548   */
 549
 550   if (tmpfilename[0])
 551     unlink(tmpfilename);
 552
 553   if (fd)
 554     close(fd);
 555
 556   if (snmp_fd >= 0)
 557     _cupsSNMPClose(snmp_fd);
 558
 559  /*
 560   * Return the queue status...
 561   */
 562
 563   return (status);
 564 }
 565
 566
 567 /*
 568  * 'lpd_command()' - Send an LPR command sequence and wait for a reply.
 569  */
 570
 571 static int                      /* O - Status of command */
 572 lpd_command(int  fd,            /* I - Socket connection to LPD host */
 573             char *format,       /* I - printf()-style format string */
 574             ...)                /* I - Additional args as necessary */
 575 {
 576   va_list       ap;             /* Argument pointer */
 577   char          buf[1024];      /* Output buffer */
 578   int           bytes;          /* Number of bytes to output */
 579   char          status;         /* Status from command */
 580
 581
 582  /*
 583   * Don't try to send commands if the job has been canceled...
 584   */
 585
 586   if (abort_job)
 587     return (-1);
 588
 589  /*
 590   * Format the string...
 591   */
 592
 593   va_start(ap, format);
 594   bytes = vsnprintf(buf, sizeof(buf), format, ap);
 595   va_end(ap);
 596
 597   fprintf(stderr, "DEBUG: lpd_command %2.2x %s", buf[0], buf + 1);
 598
 599  /*
 600   * Send the command...
 601   */
 602
 603   fprintf(stderr, "DEBUG: Sending command string (%d bytes)...\n", bytes);
 604
 605   if (lpd_write(fd, buf, bytes) < bytes)
 606   {
 607     perror("DEBUG: Unable to send LPD command");
 608     return (-1);
 609   }
 610
 611  /*
 612   * Read back the status from the command and return it...
 613   */
 614
 615   fputs("DEBUG: Reading command status...\n", stderr);
 616
 617   if (recv(fd, &status, 1, 0) < 1)
 618   {
 619     _cupsLangPrintFilter(stderr, "WARNING", _("Printer did not respond."));
 620     status = errno;
 621   }
 622
 623   fprintf(stderr, "DEBUG: lpd_command returning %d\n", status);
 624
 625   return (status);
 626 }
 627
 628
 629 /*
 630  * 'lpd_queue()' - Queue a file using the Line Printer Daemon protocol.
 631  */
 632
 633 static int                              /* O - Zero on success, non-zero on failure */
 634 lpd_queue(const char      *hostname,    /* I - Host to connect to */
 635           http_addrlist_t *addrlist,    /* I - List of host addresses */
 636           const char      *printer,     /* I - Printer/queue name */
 637           int             print_fd,     /* I - File to print */
 638           int             snmp_fd,      /* I - SNMP socket */
 639           int             mode,         /* I - Print mode */
 640           const char      *user,        /* I - Requesting user */
 641           const char      *title,       /* I - Job title */
 642           int             copies,       /* I - Number of copies */
 643           int             banner,       /* I - Print LPD banner? */
 644           int             format,       /* I - Format specifier */
 645           int             order,        /* I - Order of data/control files */
 646           int             reserve,      /* I - Reserve ports? */
 647           int             manual_copies,/* I - Do copies by hand... */
 648           int             timeout,      /* I - Timeout... */
 649           int             contimeout,   /* I - Connection timeout */
 650           const char      *orighost)    /* I - job-originating-host-name */
 651 {
 652   char                  localhost[255]; /* Local host name */
 653   int                   error;          /* Error number */
 654   struct stat           filestats;      /* File statistics */
 655   int                   lport;          /* LPD connection local port */
 656   int                   fd;             /* LPD socket */
 657   char                  control[10240], /* LPD control 'file' */
 658                         *cptr;          /* Pointer into control file string */
 659   char                  status;         /* Status byte from command */
 660   int                   delay;          /* Delay for retries... */
 661   char                  addrname[256];  /* Address name */
 662   http_addrlist_t       *addr;          /* Socket address */
 663   int                   have_supplies;  /* Printer supports supply levels? */
 664   int                   copy;           /* Copies written */
 665   time_t                start_time;     /* Time of first connect */
 666   size_t                nbytes;         /* Number of bytes written */
 667   off_t                 tbytes;         /* Total bytes written */
 668   char                  buffer[32768];  /* Output buffer */
 669 #ifdef WIN32
 670   DWORD                 tv;             /* Timeout in milliseconds */
 671 #else
 672   struct timeval        tv;             /* Timeout in secs and usecs */
 673 #endif /* WIN32 */
 674
 675
 676  /*
 677   * Remember when we started trying to connect to the printer...
 678   */
 679
 680   start_time = time(NULL);
 681
 682  /*
 683   * Loop forever trying to print the file...
 684   */
 685
 686   while (!abort_job)
 687   {
 688    /*
 689     * First try to reserve a port for this connection...
 690     */
 691
 692     fprintf(stderr, "DEBUG: Connecting to %s:%d for printer %s\n", hostname,
 693             _httpAddrPort(&(addrlist->addr)), printer);
 694     _cupsLangPrintFilter(stderr, "INFO", _("Connecting to printer."));
 695
 696     for (lport = reserve == RESERVE_RFC1179 ? 732 : 1024, addr = addrlist,
 697              delay = 5;;
 698          addr = addr->next)
 699     {
 700      /*
 701       * Stop if this job has been canceled...
 702       */
 703
 704       if (abort_job)
 705         return (CUPS_BACKEND_FAILED);
 706
 707      /*
 708       * Choose the next priviledged port...
 709       */
 710
 711       if (!addr)
 712         addr = addrlist;
 713
 714       lport --;
 715
 716       if (lport < 721 && reserve == RESERVE_RFC1179)
 717         lport = 731;
 718       else if (lport < 1)
 719         lport = 1023;
 720
 721 #ifdef HAVE_GETEUID
 722       if (geteuid() || !reserve)
 723 #else
 724       if (getuid() || !reserve)
 725 #endif /* HAVE_GETEUID */
 726       {
 727        /*
 728         * Just create a regular socket...
 729         */
 730
 731         if ((fd = socket(addr->addr.addr.sa_family, SOCK_STREAM, 0)) < 0)
 732         {
 733           perror("DEBUG: Unable to create socket");
 734           sleep(1);
 735
 736           continue;
 737         }
 738
 739         lport = 0;
 740       }
 741       else
 742       {
 743        /*
 744         * We're running as root and want to comply with RFC 1179.  Reserve a
 745         * priviledged lport between 721 and 731...
 746         */
 747
 748         if ((fd = rresvport_af(&lport, addr->addr.addr.sa_family)) < 0)
 749         {
 750           perror("DEBUG: Unable to reserve port");
 751           sleep(1);
 752
 753           continue;
 754         }
 755       }
 756
 757      /*
 758       * Connect to the printer or server...
 759       */
 760
 761       if (abort_job)
 762       {
 763         close(fd);
 764
 765         return (CUPS_BACKEND_FAILED);
 766       }
 767
 768       if (!connect(fd, &(addr->addr.addr), httpAddrLength(&(addr->addr))))
 769         break;
 770
 771       error = errno;
 772       close(fd);
 773
 774       if (addr->next)
 775         continue;
 776
 777       if (getenv("CLASS") != NULL)
 778       {
 779        /*
 780         * If the CLASS environment variable is set, the job was submitted
 781         * to a class and not to a specific queue.  In this case, we want
 782         * to abort immediately so that the job can be requeued on the next
 783         * available printer in the class.
 784         */
 785
 786         _cupsLangPrintFilter(stderr, "INFO",
 787                              _("Unable to contact printer, queuing on next "
 788                                "printer in class."));
 789
 790        /*
 791         * Sleep 5 seconds to keep the job from requeuing too rapidly...
 792         */
 793
 794         sleep(5);
 795
 796         return (CUPS_BACKEND_FAILED);
 797       }
 798
 799       fprintf(stderr, "DEBUG: Connection error: %s\n", strerror(error));
 800
 801       if (error == ECONNREFUSED || error == EHOSTDOWN ||
 802           error == EHOSTUNREACH)
 803       {
 804         if (contimeout && (time(NULL) - start_time) > contimeout)
 805         {
 806           _cupsLangPrintFilter(stderr, "ERROR",
 807                                _("The printer is not responding."));
 808           return (CUPS_BACKEND_FAILED);
 809         }
 810
 811         switch (error)
 812         {
 813           case EHOSTDOWN :
 814               _cupsLangPrintFilter(stderr, "WARNING",
 815                                    _("The printer may not exist or "
 816                                      "is unavailable at this time."));
 817               break;
 818
 819           case EHOSTUNREACH :
 820               _cupsLangPrintFilter(stderr, "WARNING",
 821                                    _("The printer is unreachable at "
 822                                      "this time."));
 823               break;
 824
 825           case ECONNREFUSED :
 826           default :
 827               _cupsLangPrintFilter(stderr, "WARNING",
 828                                    _("The printer is busy."));
 829               break;
 830         }
 831
 832         sleep(delay);
 833
 834         if (delay < 30)
 835           delay += 5;
 836       }
 837       else if (error == EADDRINUSE)
 838       {
 839        /*
 840         * Try on another port...
 841         */
 842
 843         sleep(1);
 844       }
 845       else
 846       {
 847         _cupsLangPrintFilter(stderr, "ERROR",
 848                              _("The printer is not responding."));
 849         sleep(30);
 850       }
 851     }
 852
 853    /*
 854     * Set the timeout...
 855     */
 856
 857 #ifdef WIN32
 858     tv = (DWORD)(timeout * 1000);
 859
 860     setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(tv));
 861     setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, (char *)&tv, sizeof(tv));
 862 #else
 863     tv.tv_sec  = timeout;
 864     tv.tv_usec = 0;
 865
 866     setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
 867     setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
 868 #endif /* WIN32 */
 869
 870     fputs("STATE: -connecting-to-device\n", stderr);
 871     _cupsLangPrintFilter(stderr, "INFO", _("Connected to printer."));
 872
 873     fprintf(stderr, "DEBUG: Connected to %s:%d (local port %d)...\n",
 874             httpAddrString(&(addr->addr), addrname, sizeof(addrname)),
 875             _httpAddrPort(&(addr->addr)), lport);
 876
 877    /*
 878     * See if the printer supports SNMP...
 879     */
 880
 881     if (snmp_fd >= 0)
 882       have_supplies = !backendSNMPSupplies(snmp_fd, &(addrlist->addr), NULL,
 883                                            NULL);
 884     else
 885       have_supplies = 0;
 886
 887    /*
 888     * Check for side-channel requests...
 889     */
 890
 891     backendCheckSideChannel(snmp_fd, &(addrlist->addr));
 892
 893    /*
 894     * Next, open the print file and figure out its size...
 895     */
 896
 897     if (print_fd)
 898     {
 899      /*
 900       * Use the size from the print file...
 901       */
 902
 903       if (fstat(print_fd, &filestats))
 904       {
 905         close(fd);
 906
 907         perror("DEBUG: unable to stat print file");
 908         return (CUPS_BACKEND_FAILED);
 909       }
 910
 911       filestats.st_size *= manual_copies;
 912     }
 913     else
 914     {
 915      /*
 916       * Use a "very large value" for the size so that the printer will
 917       * keep printing until we close the connection...
 918       */
 919
 920 #ifdef _LARGEFILE_SOURCE
 921       filestats.st_size = (size_t)(999999999999.0);
 922 #else
 923       filestats.st_size = 2147483647;
 924 #endif /* _LARGEFILE_SOURCE */
 925     }
 926
 927    /*
 928     * Send a job header to the printer, specifying no banner page and
 929     * literal output...
 930     */
 931
 932     if (lpd_command(fd, "\002%s\n",
 933                     printer))           /* Receive print job(s) */
 934     {
 935       close(fd);
 936       return (CUPS_BACKEND_FAILED);
 937     }
 938
 939     if (orighost)
 940       strlcpy(localhost, orighost, sizeof(localhost));
 941     else
 942       httpGetHostname(NULL, localhost, sizeof(localhost));
 943
 944     snprintf(control, sizeof(control),
 945              "H%.31s\n"         /* RFC 1179, Section 7.2 - host name <= 31 chars */
 946              "P%.31s\n"         /* RFC 1179, Section 7.2 - user name <= 31 chars */
 947              "J%.99s\n",        /* RFC 1179, Section 7.2 - job name <= 99 chars */
 948              localhost, user, title);
 949     cptr = control + strlen(control);
 950
 951     if (banner)
 952     {
 953       snprintf(cptr, sizeof(control) - (cptr - control),
 954                "C%.31s\n"       /* RFC 1179, Section 7.2 - class name <= 31 chars */
 955                "L%s\n",
 956                localhost, user);
 957       cptr   += strlen(cptr);
 958     }
 959
 960     while (copies > 0)
 961     {
 962       snprintf(cptr, sizeof(control) - (cptr - control), "%cdfA%03d%.15s\n",
 963                format, (int)getpid() % 1000, localhost);
 964       cptr   += strlen(cptr);
 965       copies --;
 966     }
 967
 968     snprintf(cptr, sizeof(control) - (cptr - control),
 969              "UdfA%03d%.15s\n"
 970              "N%.131s\n",       /* RFC 1179, Section 7.2 - sourcefile name <= 131 chars */
 971              (int)getpid() % 1000, localhost, title);
 972
 973     fprintf(stderr, "DEBUG: Control file is:\n%s", control);
 974
 975     if (order == ORDER_CONTROL_DATA)
 976     {
 977      /*
 978       * Check for side-channel requests...
 979       */
 980
 981       backendCheckSideChannel(snmp_fd, &(addr->addr));
 982
 983      /*
 984       * Send the control file...
 985       */
 986
 987       if (lpd_command(fd, "\002%d cfA%03.3d%.15s\n", strlen(control),
 988                       (int)getpid() % 1000, localhost))
 989       {
 990         close(fd);
 991
 992         return (CUPS_BACKEND_FAILED);
 993       }
 994
 995       fprintf(stderr, "DEBUG: Sending control file (%u bytes)\n",
 996               (unsigned)strlen(control));
 997
 998       if (lpd_write(fd, control, strlen(control) + 1) < (strlen(control) + 1))
 999       {
1000         status = errno;
1001         perror("DEBUG: Unable to write control file");
1002
1003       }
1004       else
1005       {
1006         if (read(fd, &status, 1) < 1)
1007         {
1008           _cupsLangPrintFilter(stderr, "WARNING",
1009                                _("Printer did not respond."));
1010           status = errno;
1011         }
1012       }
1013
1014       if (status != 0)
1015         _cupsLangPrintFilter(stderr, "ERROR",
1016                              _("Remote host did not accept control file (%d)."),
1017                              status);
1018       else
1019         _cupsLangPrintFilter(stderr, "INFO",
1020                              _("Control file sent successfully."));
1021     }
1022     else
1023       status = 0;
1024
1025     if (status == 0)
1026     {
1027      /*
1028       * Check for side-channel requests...
1029       */
1030
1031       backendCheckSideChannel(snmp_fd, &(addr->addr));
1032
1033      /*
1034       * Send the print file...
1035       */
1036
1037       if (lpd_command(fd, "\003" CUPS_LLFMT " dfA%03.3d%.15s\n",
1038                       CUPS_LLCAST filestats.st_size, (int)getpid() % 1000,
1039                       localhost))
1040       {
1041         close(fd);
1042
1043         return (CUPS_BACKEND_FAILED);
1044       }
1045
1046       fprintf(stderr, "DEBUG: Sending data file (" CUPS_LLFMT " bytes)\n",
1047               CUPS_LLCAST filestats.st_size);
1048
1049       tbytes = 0;
1050       for (copy = 0; copy < manual_copies; copy ++)
1051       {
1052         lseek(print_fd, 0, SEEK_SET);
1053
1054         while ((nbytes = read(print_fd, buffer, sizeof(buffer))) > 0)
1055         {
1056           _cupsLangPrintFilter(stderr, "INFO",
1057                                _("Spooling job, %.0f%% complete."),
1058                                100.0 * tbytes / filestats.st_size);
1059
1060           if (lpd_write(fd, buffer, nbytes) < nbytes)
1061           {
1062             perror("DEBUG: Unable to send print file to printer");
1063             break;
1064           }
1065           else
1066             tbytes += nbytes;
1067         }
1068       }
1069
1070       if (mode == MODE_STANDARD)
1071       {
1072         if (tbytes < filestats.st_size)
1073           status = errno;
1074         else if (lpd_write(fd, "", 1) < 1)
1075         {
1076           perror("DEBUG: Unable to send trailing nul to printer");
1077           status = errno;
1078         }
1079         else
1080         {
1081          /*
1082           * Read the status byte from the printer; if we can't read the byte
1083           * back now, we should set status to "errno", however at this point
1084           * we know the printer got the whole file and we don't necessarily
1085           * want to requeue it over and over...
1086           */
1087
1088           if (recv(fd, &status, 1, 0) < 1)
1089           {
1090             _cupsLangPrintFilter(stderr, "WARNING",
1091                                  _("Printer did not respond."));
1092             status = 0;
1093           }
1094         }
1095       }
1096       else
1097         status = 0;
1098
1099       if (status != 0)
1100         _cupsLangPrintFilter(stderr, "ERROR",
1101                              _("Remote host did not accept data file (%d)."),
1102                              status);
1103       else
1104         _cupsLangPrintFilter(stderr, "INFO",
1105                              _("Data file sent successfully."));
1106     }
1107
1108     if (status == 0 && order == ORDER_DATA_CONTROL)
1109     {
1110      /*
1111       * Check for side-channel requests...
1112       */
1113
1114       backendCheckSideChannel(snmp_fd, &(addr->addr));
1115
1116      /*
1117       * Send control file...
1118       */
1119
1120       if (lpd_command(fd, "\002%d cfA%03.3d%.15s\n", strlen(control),
1121                       (int)getpid() % 1000, localhost))
1122       {
1123         close(fd);
1124
1125         return (CUPS_BACKEND_FAILED);
1126       }
1127
1128       fprintf(stderr, "DEBUG: Sending control file (%lu bytes)\n",
1129               (unsigned long)strlen(control));
1130
1131       if (lpd_write(fd, control, strlen(control) + 1) < (strlen(control) + 1))
1132       {
1133         status = errno;
1134         perror("DEBUG: Unable to write control file");
1135       }
1136       else
1137       {
1138         if (read(fd, &status, 1) < 1)
1139         {
1140           _cupsLangPrintFilter(stderr, "WARNING",
1141                                _("Printer did not respond."));
1142           status = errno;
1143         }
1144       }
1145
1146       if (status != 0)
1147         _cupsLangPrintFilter(stderr, "ERROR",
1148                              _("Remote host did not accept control file (%d)."),
1149                              status);
1150       else
1151         _cupsLangPrintFilter(stderr, "INFO",
1152                              _("Control file sent successfully."));
1153     }
1154
1155    /*
1156     * Collect the final supply levels as needed...
1157     */
1158
1159     if (have_supplies)
1160       backendSNMPSupplies(snmp_fd, &(addr->addr), NULL, NULL);
1161
1162    /*
1163     * Close the socket connection and input file...
1164     */
1165
1166     close(fd);
1167
1168     if (status == 0)
1169       return (CUPS_BACKEND_OK);
1170
1171    /*
1172     * Waiting for a retry...
1173     */
1174
1175     sleep(30);
1176   }
1177
1178  /*
1179   * If we get here, then the job has been canceled...
1180   */
1181
1182   return (CUPS_BACKEND_FAILED);
1183 }
1184
1185
1186 /*
1187  * 'lpd_write()' - Write a buffer of data to an LPD server.
1188  */
1189
1190 static int                              /* O - Number of bytes written or -1 on error */
1191 lpd_write(int  lpd_fd,                  /* I - LPD socket */
1192           char *buffer,                 /* I - Buffer to write */
1193           int  length)                  /* I - Number of bytes to write */
1194 {
1195   int   bytes,                          /* Number of bytes written */
1196         total;                          /* Total number of bytes written */
1197
1198
1199   if (abort_job)
1200     return (-1);
1201
1202   total = 0;
1203   while ((bytes = send(lpd_fd, buffer, length - total, 0)) >= 0)
1204   {
1205     total  += bytes;
1206     buffer += bytes;
1207
1208     if (total == length)
1209       break;
1210   }
1211
1212   if (bytes < 0)
1213     return (-1);
1214   else
1215     return (length);
1216 }
1217
1218
1219 #ifndef HAVE_RRESVPORT_AF
1220 /*
1221  * 'rresvport_af()' - A simple implementation of rresvport_af().
1222  */
1223
1224 static int                              /* O  - Socket or -1 on error */
1225 rresvport_af(int *port,                 /* IO - Port number to bind to */
1226              int family)                /* I  - Address family */
1227 {
1228   http_addr_t   addr;                   /* Socket address */
1229   int           fd;                     /* Socket file descriptor */
1230
1231
1232  /*
1233   * Try to create an IPv4 socket...
1234   */
1235
1236   if ((fd = socket(family, SOCK_STREAM, 0)) < 0)
1237     return (-1);
1238
1239  /*
1240   * Initialize the address buffer...
1241   */
1242
1243   memset(&addr, 0, sizeof(addr));
1244   addr.addr.sa_family = family;
1245
1246  /*
1247   * Try to bind the socket to a reserved port...
1248   */
1249
1250   while (*port > 511)
1251   {
1252    /*
1253     * Set the port number...
1254     */
1255
1256     _httpAddrSetPort(&addr, *port);
1257
1258    /*
1259     * Try binding the port to the socket; return if all is OK...
1260     */
1261
1262     if (!bind(fd, (struct sockaddr *)&addr, sizeof(addr)))
1263       return (fd);
1264
1265    /*
1266     * Stop if we have any error other than "address already in use"...
1267     */
1268
1269     if (errno != EADDRINUSE)
1270     {
1271 #  ifdef WIN32
1272       closesocket(fd);
1273 #  else
1274       close(fd);
1275 #  endif /* WIN32 */
1276
1277       return (-1);
1278     }
1279
1280    /*
1281     * Try the next port...
1282     */
1283
1284     (*port)--;
1285   }
1286
1287  /*
1288   * Wasn't able to bind to a reserved port, so close the socket and return
1289   * -1...
1290   */
1291
1292 #  ifdef WIN32
1293   closesocket(fd);
1294 #  else
1295   close(fd);
1296 #  endif /* WIN32 */
1297
1298   return (-1);
1299 }
1300 #endif /* !HAVE_RRESVPORT_AF */
1301
1302
1303 /*
1304  * 'sigterm_handler()' - Handle 'terminate' signals that stop the backend.
1305  */
1306
1307 static void
1308 sigterm_handler(int sig)                /* I - Signal */
1309 {
1310   (void)sig;    /* remove compiler warnings... */
1311
1312   abort_job = 1;
1313 }
1314
1315
1316 /*
1317  * End of "$Id: lpd.c 7740 2008-07-14 23:58:05Z mike $".
1318  */