home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Netzwerk / port-lpr.lha / lpr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-28  |  24.7 KB  |  1,047 lines
  1. /*
  2.  * "lpr" program for systems that don't have lpd but can talk to a system
  3.  * that does using TCP or DECnet
  4.  *
  5.  * Copyright (C) 1990, 1991 Keith Moore
  6.  
  7.  * This program is free software; you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License, Version 1,
  9.  * as published by the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; if not, write to the Free Software
  18.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  *
  20.  * Written by Keith Moore, December 1990
  21.  * Email: moore@cs.utk.edu (Internet)    moore@utkvx (BITNET)
  22.  * Snail: Box 16320 / Knoxville TN  37996 / USA
  23.  */
  24.  
  25. /* TO DO:
  26.  * - send troff font names
  27.  * - add support for /etc/printcap files.
  28.  * - add options for lpq, lprm commands
  29.  * - special hacks for Imagen and/or PostScript printers (maybe)
  30.  * - support -i (indent) and -w (page width) options
  31.  * - handle huge files too big to read into memory (UNIX systems only)
  32.  * - recognize ditroff, raster, cifplot, and FORTRAN output files (maybe)
  33.  * - instead of MAX_READ and MAX_WRITE, use MAX_{FILE,SOCKET}_{READ,WRITE}
  34.  * - handle multiple lpd servers -- try each until we find one that's up.
  35.  * - allow printer names of the form printer@host or host::printer,
  36.  *   or add a -S option to specify print server on command line.
  37.  * - add an option to specify job-id (for use when using this program
  38.  *   as the back-end to another print spooling system -- you can keep the
  39.  *   job-ids the same on both systems if you're lucky).
  40.  * - add an option to wait until the job is actually printed -- this is
  41.  *   not easy to do but is very useful when this program is being used
  42.  *   as the back-end to another kind of print spooler.
  43.  */
  44.  
  45. #include "config.h"
  46. #include "patchlevel.h"
  47. #include <stdio.h>
  48. #include <stdlib.h>
  49. #include <string.h>
  50. #include <fcntl.h>
  51. #include <ctype.h>
  52. #include <time.h>
  53.  
  54. #define VERSION 1
  55.  
  56. char hostname[512];        /* name of this host */
  57. char username[100];        /* name of submitting user */
  58. char lpd_server[512];        /* name of host running lpd */
  59. char email_address[512];    /* sender's email address */
  60.  
  61. /*
  62.  * options...not all of which are supported
  63.  */
  64. char *printer;            /* name of remote print queue */
  65. char file_type = '?';        /* kind of file to be printed */
  66. char *title = NULL;        /* page headings for pr */
  67. char *jobtitle = NULL;        /* job name */
  68. char *jobclass = NULL;        /* job class */
  69. int num_copies = 1;        /* number of copies to print */
  70. int indent = 0;            /* # of spaces to indent */
  71. int page_width = 72;        /* page width for pr */
  72. char *fontnames[4];        /* names of troff fonts */
  73. int rflag = 0;            /* if 1, remove file after spooling */
  74. int mflag = 0;            /* if 1, send mail on completion */
  75. int hflag = 0;            /* if 1, omit burst page */
  76. int debug = 0;
  77.  
  78. #ifndef __STDC__
  79. #define min(a,b) ((a) < (b) ? (a) : (b))
  80. char *getenv ();
  81. char *calloc ();
  82. char *realloc ();
  83. char *strrchr ();
  84. #endif
  85.  
  86. /*
  87.  * Initialize system-dependent variables
  88.  */
  89.  
  90. #ifdef vms
  91. #include <stat.h>
  92.  
  93. void
  94. sysdep (void)
  95. {
  96.     char *p;
  97.     /* really need to use sys$trnlog here instead of getenv */
  98.     if (p = getenv ("SYS$NODE"))
  99.     strcpy (hostname, p);
  100.     else {
  101.     fprintf (stderr, "lpr: no translation for logical SYS$NODE\n");
  102.     exit (1);
  103.     }
  104.     cuserid (username);
  105.     sprintf (email_address, "%s::%s", hostname, username);
  106.     for (p = hostname; *p; ++p)
  107.     if (isupper (*p))
  108.         *p = tolower (*p);
  109.     if (p = getenv ("LPD_SERVER")) {
  110.     strcpy (lpd_server, p);
  111.     for (p = hostname; *p; ++p)
  112.         if (islower (*p))
  113.         *p = toupper (*p);
  114.     }
  115.     else {
  116.     fprintf (stderr, "lpr: no translation for logical name LPD_SERVER\n");
  117.     exit (1);
  118.     }
  119. }
  120. #endif
  121.  
  122. #ifdef unix
  123. #include <sys/types.h>
  124. #include <sys/stat.h>
  125. #include <pwd.h>
  126. #include <netdb.h>
  127.  
  128. void
  129. sysdep (void)
  130. {
  131.     struct passwd *pwd;
  132.     char *p;
  133.     struct hostent *hp;
  134.  
  135.     gethostname (hostname, sizeof hostname);
  136.     if (pwd = getpwuid (getuid ()))
  137.     strcpy (username, pwd->pw_name);
  138.     else {
  139.     fprintf (stderr, "lpr: system problem: can't get your username!\n");
  140.     exit (1);
  141.     }
  142.     if (p = getenv ("LPD_SERVER"))
  143.     strcpy (lpd_server, p);
  144.     else {
  145.     fprintf (stderr, "lpr: LPD_SERVER environment variable is not set\n");
  146.     exit (1);
  147.     }
  148.     hp = gethostbyname (hostname);
  149.     sprintf (email_address, "%s@%s", username, hp ? hp->h_name : hostname);
  150. }
  151. #endif
  152.  
  153. /*
  154.  * Open a channel to the print spooler
  155.  * returns an fd on success
  156.  * Print a message and return EOF on failure
  157.  */
  158.  
  159. #if use_decnet
  160. /*
  161.  * Code to open a DECnet channel to an lpd gateway
  162.  */
  163. #define MAX_READ 512
  164. #define MAX_WRITE 512
  165.  
  166. #ifdef vms
  167. int
  168. open_lpd (void)
  169. {
  170.     int fd;
  171.     char buf[512];
  172.     sprintf (buf, "%s::\"223=\"", lpd_server);
  173.     if ((fd = open ("%s::\"223=\"", 2)) < 0)
  174.     perror ("Cannot open remote DECnet printer daemon");
  175.     return fd;
  176. }
  177. #endif
  178.  
  179. #ifdef sun
  180. /* code for sunlink dni goes here */
  181. #endif
  182.  
  183. #ifdef ultrix
  184. /* code for DECnet ultrix goes here */
  185. #endif
  186.  
  187. #endif                /* use_decnet */
  188.  
  189.  
  190. #if use_tcp
  191. #define MAX_READ 32000
  192. #define MAX_WRITE 32000
  193.  
  194. /*
  195.  * Code to open a TCP connection to lpd
  196.  * This requires that this program be run set-uid to root in order
  197.  * to be able to bind to a privileged port.
  198.  */
  199.  
  200. #ifdef unix
  201. #include <sys/socket.h>
  202. #include <errno.h>
  203. #include <netinet/in.h>
  204.  
  205. int
  206. open_lpd (void)
  207. {
  208.     int fd;
  209.     int port;
  210.     struct hostent *hp;
  211.     struct servent *sp;
  212.     struct sockaddr_in s;
  213.  
  214.     if ((fd = socket (AF_INET, SOCK_STREAM, 0)) == EOF) {
  215.     perror ("socket");
  216.     return EOF;
  217.     }
  218.     for (port = IPPORT_RESERVED-1; port > IPPORT_RESERVED / 2; port--) {
  219.     extern int errno;
  220.     s.sin_family = AF_INET;
  221.     s.sin_addr.s_addr = INADDR_ANY;
  222.     s.sin_port = htons (port);
  223.     if (bind (fd, (struct sockaddr *) &s, sizeof (s)) == 0)
  224.         break;
  225.     if (errno == EACCES) {
  226.         fprintf (stderr, "lpr: bind: cannot bind to privileged port\n");
  227.         return EOF;
  228.     }
  229.     }
  230.     if ((hp = gethostbyname (lpd_server)) == NULL) {
  231.     fprintf (stderr, "lpr: can't find network address for %s\n",
  232.          lpd_server);
  233.     fflush (stderr);
  234.     return EOF;
  235.     }
  236.     bcopy (hp->h_addr, (char *) &s.sin_addr, hp->h_length);
  237.     if ((sp = getservbyname ("printer", "tcp")) == NULL)
  238.     s.sin_port = htons (515);
  239.     else
  240.     s.sin_port = sp->s_port;
  241.     if (connect (fd, (struct sockaddr *)&s, sizeof s) < 0) {
  242.     perror ("connect");
  243.     close (fd);
  244.     return EOF;
  245.     }
  246.  
  247.     /* turn off set-uid privileges -- we no longer need them! */
  248.     setuid (getuid ());
  249.  
  250.     return fd;
  251. }
  252. #endif
  253. #endif                /* use_tcp */
  254.  
  255.  
  256. #if use_dev_printer
  257. #define MAX_READ 8000
  258. #define MAX_WRITE 8000
  259.  
  260. /*
  261.  * NB:  This code doesn't work with BSD lpd...
  262.  *
  263.  * I tried opening the UNIX domain socket named /dev/printer and talking
  264.  * to the spooler that way.  This fails because of a bug in lpd ... it
  265.  * waits for end of file on its input socket before submitting the job,
  266.  * but then it tries to write an ack byte back to the socket before
  267.  * printing ... which causes a SIGPIPE signal since we have closed
  268.  * the socket.  I tried doing a shutdown(fd, 1) on the socket instead
  269.  * from this end, but then lpd waits forever for more input.  Apparently
  270.  * writing a single byte on a TCP socket that is closed on the other
  271.  * end doesn't cause a SIGPIPE.  I even tried using SO_DONTLINGER to
  272.  * see if that would keep a SIGPIPE from happening...but no luck.
  273.  */
  274.  
  275. #include <sys/socket.h>
  276. #include <sys/un.h>
  277.  
  278. int
  279. open_lpd (void)
  280. {
  281.     int fd;
  282.     struct sockaddr_un s;
  283. #ifndef SO_DONTLINGER
  284.     struct linger linger;
  285. #endif
  286.  
  287.     fd = socket (AF_UNIX, SOCK_STREAM, 0);
  288.     if (fd < 0) {
  289.         perror ("Can't create socket to connect to print spooler");
  290.         return fd;
  291.     }
  292. #ifdef SO_DONTLINGER
  293.     if (setsockopt (fd, SOL_SOCKET, SO_DONTLINGER, 0, 0) < 0)
  294.     perror ("setsockopt");
  295. #else
  296.     linger.l_onoff = 0;
  297.     linger.l_linger = 0;
  298.     if (setsockopt (fd, SOL_SOCKET, SO_LINGER, &linger, sizeof linger) < 0)
  299.     perror ("setsockopt");
  300. #endif
  301.     s.sun_family = AF_UNIX;
  302.     strcpy (s.sun_path, "/dev/printer");
  303.     if (connect (fd, &s, sizeof s) < 0){
  304.         perror ("Cannot connect to print spooler");
  305.         close (fd);
  306.         return EOF;
  307.     }
  308.     return fd;
  309. }
  310.  
  311. #endif                /* use_dev_printer */
  312.  
  313. /*
  314.  * debugging routines
  315.  */
  316.  
  317. void
  318. dump_buf (FILE *fp, char *prefix, char *buf, int size)
  319. {
  320.     fprintf (fp, "%s", prefix);
  321.     while (size > 0){
  322.         if (*buf >= ' ' && *buf <= '~')
  323.             putc (*buf, fp);
  324.         else if (*buf == '\n')
  325.             fprintf (fp, "\\n");
  326.         else
  327.             fprintf (fp, "\\%03o", *buf);
  328.         ++buf;
  329.         --size;
  330.     }
  331.     fprintf (fp, "\n");
  332. }
  333.  
  334.  
  335. int
  336. x_read (int fd, char *buf, unsigned size)
  337. {
  338.     int nread = read (fd, (char *) buf, size);
  339.     if (debug)
  340.     dump_buf (stderr, "<<<", buf, nread);
  341.     return nread;
  342. }
  343.  
  344. int
  345. x_write (int fd, char *buf, unsigned size)
  346. {
  347.     if (debug)
  348.     dump_buf (stderr, ">>>", buf, size);
  349.     return write (fd, (char *) buf, size);
  350. }
  351.  
  352. int
  353. y_write (int fd, char *buf, unsigned size)
  354. {
  355.     if (debug)
  356.     fprintf (stderr, ">>> (%d bytes)\n", size);
  357.     return write (fd, (char *) buf, size);
  358. }
  359.  
  360.  
  361. /*
  362.  * parse an option with an optional argument (which may be NULL)
  363.  * return 1 if optional argument used, else 0
  364.  * (one of these days I'll start using getopt())
  365.  */
  366. int
  367. real_option (char *opt, char *arg)
  368. {
  369.     if (opt[1] && opt[2] == '\0') {
  370.     /* single letter options */
  371.     switch (opt[1]) {
  372.     case 'd':        /* TeX .dvi file */
  373.     case 'f':        /* ordinary text file (add page breaks) */
  374.     case 'g':        /* UNIX plot file */
  375.     case 'l':        /* text file with embedded control chars */
  376.     case 'n':        /* ditroff output file */
  377.     case 'o':        /* PostScript file */
  378.     case 'p':        /* text file (add page headers using pr) */
  379.     case 'r':        /* FORTRAN output file w/carraige control  */
  380.     case 't':        /* C/A/T troff output file*/
  381.     case 'v':        /* Versatec output file */
  382.         file_type = opt[1];
  383.         return 0;
  384.     case 'P':        /* -P printer */
  385.     case 'q':        /* -q queue (same thing) */
  386.         printer = arg;
  387.         return 1;
  388.     case '#':        /* num copies */
  389.         if (arg && isdigit (*arg)) {
  390.         num_copies = atoi (arg);
  391.         return 1;
  392.         }
  393.         break;
  394.     case 'C':        /* job class (default: local hostname) */
  395.         jobclass = arg;
  396.         return 1;
  397.     case 'J':        /* job title (default: first file name) */
  398.         jobtitle = arg;
  399.         return 1;
  400.     case 'i':        /* indent output (default: 8 chars) */
  401.         if (arg && isdigit (*arg)) {
  402.         indent = atoi (arg);
  403.         return 1;
  404.         }
  405.         else {
  406.         indent = 8;
  407.         return 0;
  408.         }
  409.     case '1':        /* troff font names */
  410.     case '2':
  411.     case '3':
  412.     case '4':
  413.         fontnames[opt[1]-'1']=arg;
  414.         return 1;
  415.     case 'w':        /* cols -- page width for pr */
  416.         if (arg && isdigit (*arg)) {
  417.         page_width = atoi (arg);
  418.         return 1;
  419.         }
  420. #if 0
  421.         /* conflicts with -r (print FORTRAN file)...which is right? */
  422.     case 'r':        /* remove file after spooling */
  423.         rflag = 1;
  424.         return 0;
  425. #endif
  426.     case 'm':        /* send mail upon completion */
  427.         mflag = 1;
  428.         return 0;
  429.     case 'h':        /* don't print the burst page */
  430.         hflag = 1;
  431.         return 0;
  432.     case 's':        /* don't copy file -- symlink it */
  433.         fprintf (stderr,
  434.              "lpr: The -s (symlink) option is not supported\n");
  435.         fprintf (stderr,
  436.              "All files will be copied to the remote server\n");
  437.         return 0;
  438.     }
  439.     }
  440.     if (strcmp (opt, "-debug") == 0) {
  441.     debug = 1;
  442.     fprintf (stderr, "standalone lpr version %d.%d",
  443.          VERSION, PATCHLEVEL);
  444.     return 0;
  445.     }
  446.     fprintf (stderr, "lpr: warning: illegal option %s\n", opt);
  447.     return 0;
  448. }
  449.  
  450. int
  451. option (char *opt, char *optarg)
  452. {
  453.     /*
  454.      * This hack is used to notice whether the argument for an option
  455.      * is appended to the option itself (e.g. "-Pprinter" rather than
  456.      * "-P" "printer".  If this is the case, and the option accepts an
  457.      * argument, split the arg into two args and call real_option().
  458.      * otherwise just pass our args to real_option().
  459.      */
  460.   
  461.     if (opt[2] && strchr ("P#CJTi1234w", opt[1])) {
  462.     char temp[3];
  463.     temp[0] = '-';
  464.     temp[1] = opt[1];
  465.     temp[2] = '\0';
  466.     real_option (temp, opt + 2);
  467.     return 0;
  468.     }
  469.     else
  470.     return real_option (opt, optarg);
  471. }
  472.  
  473. /*
  474.  * keep up with files to be deleted (for when using -r)
  475.  * This is so we don't delete files until we *know* that the job
  476.  * has been successfully submitted.
  477.  */
  478.  
  479. struct delete_list {
  480.     char *name;
  481.     struct delete_list *next;
  482. } *head = NULL;
  483.  
  484. void
  485. mark_for_delete (char *name)
  486. {
  487.     struct delete_list *ptr = (struct delete_list *)
  488.     calloc (1, sizeof (struct delete_list));
  489.     if (!ptr) {
  490.     perror ("calloc");
  491.     return;
  492.     }
  493.     ptr->next = head;
  494.     ptr->name = name;
  495.     head = ptr;
  496. }
  497.  
  498. void
  499. delete_marked_files (void)
  500. {
  501.     struct delete_list *ptr;
  502.     for (ptr = head; ptr; ptr=ptr->next) {
  503.     if (ptr->name)
  504.         if (unlink (ptr->name) < 0) {
  505.         fprintf (stderr, "lpr: could not delete %s\n", ptr->name);
  506.         perror ("unlink");
  507.         }
  508.     }
  509. }
  510.  
  511. /*
  512.  * buffer management
  513.  */
  514. struct buffer {
  515.     char *ptr;            /* points to current append point */
  516.     int size;            /* how big is the buffer now? */
  517.     char text[1];        /* (extensible) array of bytes in the buffer */
  518. };
  519.  
  520. /*
  521.  * Create an empty buffer
  522.  */
  523.  
  524. struct buffer *
  525. create_buffer (unsigned int initial_size)
  526. {
  527.     struct buffer *buf;
  528.     if (initial_size <= 0)
  529.     initial_size = 1000;
  530.     if ((buf = (struct buffer *)
  531.      calloc (1, sizeof (struct buffer) + initial_size - 1)) == NULL)
  532.     return NULL;
  533.     buf->ptr = buf->text;
  534.     buf->size = initial_size;
  535.     return buf;
  536. }
  537.  
  538. /*
  539.  * Ensure there is enough room in the buffer for "more" more bytes
  540.  */
  541. struct buffer *
  542. enlarge_buffer (struct buffer *buf, unsigned int more)
  543. {
  544.     int offset = buf->ptr - buf->text;
  545.     int space = buf->size - offset;
  546.     if (more > space) {
  547.     int newsize = sizeof (struct buffer) + (buf->size * 2) - 1;
  548.     buf = (struct buffer *) realloc ((char *) buf, newsize);
  549.     if (buf == NULL)
  550.         return NULL;
  551.     buf->ptr = buf->text + offset;
  552.     buf->size = newsize;
  553.     }
  554.     return buf;
  555. }
  556.  
  557. /*
  558.  * Append up to max_size bytes from an open file to buffer
  559.  */
  560.  
  561. int
  562. read_file_into_buffer (struct buffer *buf, int fd, unsigned max_size)
  563. {
  564.     int real_size = 0;
  565.     while (max_size > 0)  {
  566.     int foo = min (max_size, MAX_READ);
  567.     if (enlarge_buffer (buf, foo) == NULL)
  568.         return EOF;
  569.     if ((foo = read (fd, buf->ptr, foo)) < 0)
  570.         return EOF;
  571.     if (foo == 0)
  572.         break;
  573.     buf->ptr += foo;
  574.     max_size -= foo;
  575.     real_size += foo;
  576.     }
  577.     return real_size;
  578. }
  579.  
  580. /*
  581.  * Append a NUL-terminated string to the buffer
  582.  */
  583.  
  584. void
  585. append_string_to_buffer (struct buffer *buf, char *string, int length)
  586. {
  587.     if (enlarge_buffer (buf, length) == NULL) {
  588.     fprintf (stderr, "lpr: file too big to fit in memory\n");
  589.     exit (1);
  590.     }
  591.     strncpy (buf->ptr, string, length);
  592.     buf->ptr += length;
  593. }
  594.  
  595. /*
  596.  * Write out the entire contents of buffer to the file fd.
  597.  */
  598.  
  599. int
  600. send_file_from_buffer (int fd, struct buffer *buf)
  601. {
  602.     char *wptr = buf->text;
  603.     while (wptr < buf->ptr) {
  604.     int foo = min (buf->ptr - wptr, MAX_WRITE);
  605.     if ((foo = y_write (fd, wptr, foo)) < 0)
  606.         return EOF;
  607.     wptr += foo;
  608.     }
  609.     return 0;
  610. }
  611.  
  612. /*
  613.  * free up a buffer
  614.  */
  615.  
  616. void
  617. free_buffer (struct buffer *buf)
  618. {
  619.     if (buf)
  620.     cfree (buf);
  621. }
  622.  
  623. int
  624. buffer_size (struct buffer *buf)
  625. {
  626.     if (buf)
  627.     return (buf->ptr - buf->text);
  628.     return EOF;
  629. }
  630.  
  631. /*
  632.  * Look at a file buffer and guess what kind of file it is.  This is called
  633.  * when we aren't given an explicit file type option.
  634.  */
  635.  
  636. char
  637. guess_file_type (struct buffer *buf, char *fname)
  638. {
  639.     char *ptr = buf->text;
  640.     if (ptr[0] == '%' && ptr[1] == '!') {
  641.     fprintf (stderr, "lpr: %s is a PostScript (tm) file, assuming -f\n",
  642.          fname);
  643.     return 'f';        /* PostScript */
  644.     }
  645.     if (ptr[0] == '\367' && ptr[1] == 2) {
  646.     fprintf (stderr, "lpr: %s is a TeX .dvi file, assuming -d\n", fname);
  647.     return 'd';        /* TeX .dvi file */
  648.     }
  649.     if (ptr[0] == '\100' && ptr[1] == '\357')  {
  650.     fprintf (stderr, "lpr: %s is a C/A/T troff output file, assuming -t\n",
  651.          fname);
  652.     return 't';        /* C/A/T troff file */
  653.     }
  654.     return 'f';
  655. }
  656.  
  657. int
  658. check_for_bogus_file (struct buffer *buf, char type, char *filename)
  659. {
  660.     char *ptr = buf->text;
  661.  
  662.     if (buf->ptr == buf->text) {
  663.     fprintf (stderr, "lpr: skipping zero-length file %s\n", filename);
  664.     return EOF;
  665.     }
  666.     
  667.     if (ptr[0] == '\037' && ptr[1] == '\235') {
  668.     fprintf (stderr, "lpr: %s is a compressed file -- ignoring it\n",
  669.          filename);
  670.     return EOF;
  671.     }
  672.     if (type == 'd') {
  673.     if (ptr[0] == '\367' && ptr[1] == '\002') {
  674.         /* sometimes .dvi files have trailing NULs when they
  675.            shouldn't have.  Remove these from the buffer and
  676.            check that the .dvi file ends with a \337 byte. */
  677.         if (buf->ptr[-1] == '\0') {
  678.         while (buf->ptr[-1] == '\0')
  679.             --(buf->ptr);
  680.         }
  681.         if (buf->ptr[-1] == '\337')
  682.         return 0;
  683.     }
  684.     fprintf (stderr, "lpr: %s is not a valid .dvi file", filename);
  685.     return EOF;
  686.     }
  687.     if (memcmp (ptr, "!<arch>\n", 8) == 0) {
  688.     fprintf (stderr, "lpr: %s is a UNIX library archive -- ignoring it",
  689.          filename);
  690.     return EOF;
  691.     }
  692.     return 0;
  693. }
  694.  
  695.  
  696. /*
  697.  * Send a command to the remote server and wait for a response.  Return
  698.  * the first byte of the response, or EOF on error.
  699.  */
  700.  
  701. int
  702. send_command (int fd, char *buf, int size)
  703. {
  704.     char x[1];
  705.     if (x_write (fd, buf, size) != size)
  706.     return EOF;
  707.     if (x_read (fd, x, 1) != 1)
  708.     return EOF;
  709.     return *x;
  710. }
  711.  
  712.  
  713. /*
  714.  * structure used to keep track of print jobs
  715.  */
  716. struct job {
  717.     int jobid;            /* integer job id 1-999 */
  718.     int fd;            /* fd of lpd socket */
  719.     int control_file_number;    /* current file number */
  720.     int data_file_number;    /* data_file_number */
  721.     struct buffer *cfile;    /* buffer to build control file */
  722. };
  723.  
  724. /*
  725.  * add a record to a control file
  726.  */
  727. void
  728. control (struct job *job, char cmd, char *arg)
  729. {
  730.     char buf[512];
  731.     sprintf (buf, "%c%s\n", cmd, arg);
  732.     append_string_to_buffer (job->cfile, buf, strlen (buf));
  733. }
  734.  
  735.  
  736. /*
  737.  * create a print job.  Return a job ptr on success or NULL on error.
  738.  */
  739. struct job *
  740. open_job (char *queuename)
  741. {
  742.     struct job *job;
  743.     char buf[512];
  744.     char x;
  745.  
  746.     if ((job = (struct job *) calloc (1, sizeof (struct job))) == NULL)
  747.     return NULL;
  748.     /*
  749.      * generate a job #.  Really, this should be maintained on a
  750.      * per-(host,queue) basis, so we won't have naming conflicts.
  751.      * for now, we just generate something pseudo-random.
  752.      */
  753.     job->jobid = time (0) % 1000;
  754.     if ((job->fd = open_lpd ()) < 0) {
  755.     free (job);
  756.     return NULL;
  757.     }
  758.  
  759.     sprintf (buf, "\2%s\n", queuename);
  760.     if ((x = send_command (job->fd, buf, strlen (buf))) != 0) {
  761.     if (isprint (x)) {
  762.         int foo;
  763.         *buf = x;
  764.         foo = x_read (job->fd, buf+1, sizeof(buf)-1);
  765.         fprintf (stderr, "lpr: %.*s", foo+1, buf);
  766.     }
  767.     else {
  768.         fprintf (stderr,
  769.              "lpr: server %s refused job for printer %s\n",
  770.              lpd_server, queuename);
  771.     }
  772.     close (job->fd);
  773.     free (job);
  774.     return NULL;
  775.     }
  776.  
  777.     job->control_file_number = 0;
  778.     job->data_file_number = 0;
  779.     job->cfile = create_buffer (1000);
  780.  
  781.     control (job, 'H', hostname);
  782.     control (job, 'P', username);
  783.     if (hflag == 0) {
  784.     control (job, 'J', jobtitle);
  785.     control (job, 'C', jobclass);
  786.     }
  787.     control (job, 'L', username);
  788.     if (title)
  789.     control (job, 'T', title);
  790.     if (mflag)
  791.     control (job, 'M', email_address);
  792.     return job;
  793. }
  794.  
  795. void
  796. concoct_file_name (char c, struct job *job, char *str)
  797. {
  798.     int x = c == 'd' ? job->data_file_number++ : job->control_file_number++;
  799.     sprintf (str, "%cf%c%03d%s", c,
  800.          "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"[x],
  801.          job->jobid, hostname);
  802. }
  803.  
  804. /*
  805.  * Send a file to be printed.  Return 1 on success and 0 on error.
  806.  * (i.e. # of files sent). 
  807.  * print diagnostic messages to stderr as necessary
  808.  * If file == NULL, print standard input
  809.  */
  810. int
  811. send_print_file (struct job *job, char *file, char file_type)
  812. {
  813.     int estimated_size;        /* how big we think the file is */
  814.     int max_size;        /* max size to print */
  815.     int fd = EOF;        /* fd of file */
  816.     struct buffer *dfile = NULL; /* buffer to read file into */
  817.     char *reason = NULL;    /* reason file xfer failed */
  818.     char data_file_name[512];    /* name of temporary data file */
  819.     char buf[512];
  820.     int x;
  821.     int i;
  822.  
  823.     /*
  824.      * open the file and find out how big it is
  825.      * estimated_size is used to determine how much space to allocate.
  826.      * max_size is used to decide how much to read in.  Under VMS
  827.      * we don't ever want to read too much, because we might get
  828.      * unwanted garbage at the end of a fixed-length record file.
  829.      */
  830.     if (file) {
  831.     struct stat sbuf;    
  832.     if (stat (file, &sbuf) < 0) {
  833.         perror (file);
  834.         return 0;
  835.     }
  836.     max_size = estimated_size = sbuf.st_size;
  837.     if ((fd = open (file, 0)) < 0) {
  838.         perror (file);
  839.         return 0;
  840.     }
  841.     }
  842.     else {
  843.     struct stat sbuf;
  844.     file = "standard input"; /* for page headers, error messages */
  845.     estimated_size = 64000;
  846.     max_size = 5*1024*1024;    /* 5 megabytes */
  847.     fd = 0;
  848. #ifdef unix
  849.     /*
  850.      * if standard input is an ordinary file, get size estimate
  851.      * with fstat()
  852.      */
  853.     if (fstat (fd, &sbuf) < 0) {
  854.         if ((sbuf.st_mode & S_IFMT) == S_IFREG)
  855.         estimated_size = sbuf.st_size;
  856.     }
  857. #endif
  858.     }
  859.  
  860.     /*
  861.      * create a buffer and read the file into it.
  862.      */
  863.     concoct_file_name ('d', job, data_file_name);
  864.     if ((dfile = create_buffer (estimated_size)) == NULL) {
  865.         reason = "file too big to fit in memory";
  866.     goto abort;
  867.     }
  868.     if (read_file_into_buffer (dfile, fd, max_size) < 0) {
  869.     reason = "error reading file";
  870.     goto abort;
  871.     }
  872.  
  873.     /*
  874.      * file transfer successful.  Add this file to the print job,
  875.      * clean up, and return.
  876.      */
  877.     if (file_type == '?')
  878.     file_type = guess_file_type (dfile, file);
  879.     /*
  880.      * check for bogus file formats.  Refuse to print anything that
  881.      * is obviously bogus.
  882.      */
  883.     if (check_for_bogus_file (dfile, file_type, file))
  884.     goto okay;
  885.  
  886.     /*
  887.      * transfer the file to the server, with error checking
  888.      */
  889.     sprintf (buf, "\3%d %s\n", buffer_size(dfile), data_file_name);
  890.     if ((x = send_command (job->fd, buf, strlen (buf))) != 0) {
  891.     switch (x) {
  892.     case 1:
  893.         break;
  894.     case 2:
  895.         reason = "not enough disk space on server (or file is too large)";
  896.         break;
  897.     case EOF:
  898.         reason = "connection to printer server broken";
  899.         break;
  900.     default:
  901.         if (isprint (x)) {
  902.         *buf = x;
  903.         x = x_read (job->fd, buf + 1, sizeof (buf) - 1);
  904.         buf[x+1] = '\0';
  905.         reason = buf;
  906.         }
  907.     }
  908.     goto abort;
  909.     }
  910.     if (send_file_from_buffer (job->fd, dfile) != 0)
  911.     goto abort;
  912.     if (send_command (job->fd, "", 1) < 0)
  913.     goto abort;
  914.  
  915.     if (file_type == 'p' && !title)
  916.     control (job, 'P', file);
  917.     for (i = 0; i < num_copies; ++i)
  918.     control (job, file_type, data_file_name);
  919.     control (job, 'U', data_file_name);
  920.     control (job, 'N', file);
  921.  okay:
  922.     free_buffer (dfile);
  923.     close (fd);
  924.     return 1;
  925.  
  926.  
  927.     /*
  928.      * file transfer failed.  print error message and clean up
  929.      */
  930.  abort:
  931.     fprintf (stderr, "lpr: unable to send file %s to print server %s\n",
  932.          file, lpd_server);
  933.     if (reason)
  934.     fprintf (stderr, "reason: %s\n", reason);
  935.     if (dfile)
  936.     free_buffer (dfile);
  937.     if (fd > 0)
  938.     close (fd);
  939.     return 0;
  940. }
  941.  
  942. /*
  943.  * send the control file.  Return 0 on success, nonzero on error.
  944.  */
  945. send_control_file (struct job *job)
  946. {
  947.     char buf[512];
  948.     char control_file_name[512];
  949.  
  950.     concoct_file_name ('c', job, control_file_name);
  951.     sprintf (buf, "\2%d %s\n", job->cfile->ptr - job->cfile->text,
  952.          control_file_name);
  953.     if (send_command (job->fd, buf, strlen (buf)) < 0)
  954.     return 1;
  955.     if (send_file_from_buffer (job->fd, job->cfile) != 0)
  956.     return 1;
  957.     if (send_command (job->fd, "", 1) < 0)
  958.     return 1;
  959.     return 0;
  960. }
  961.  
  962. /*
  963.  * close a job normally and delete its resources
  964.  */
  965. int
  966. close_job (struct job *job)
  967. {
  968.     int x;
  969.     if (job == NULL)
  970.     return EOF;
  971.     x = send_control_file (job);
  972.     if (job->cfile)
  973.     free_buffer (job->cfile);
  974.     close (job->fd);
  975.     cfree (job);
  976.     return x;
  977. }
  978.  
  979. /*
  980.  * abort a job and delete its resources
  981.  */
  982. void
  983. abort_job (struct job *job)
  984. {
  985.     if (job == NULL)
  986.     return;
  987.     x_write (job->fd, "\1\n", 2);
  988.     close (job->fd);
  989.     if (job->cfile)
  990.     free_buffer (job->cfile);
  991.     cfree (job);
  992. }
  993.  
  994.  
  995. main (int argc, char **argv)
  996. {
  997. /*    char *printer; hided a global */
  998.     struct job *job = NULL;
  999.     int i;
  1000.     int file_args = 0;
  1001.     int files_printed = 0;
  1002.  
  1003.     printer = getenv ("PRINTER");
  1004.     if (printer == NULL)
  1005.     printer = "lp";
  1006.  
  1007.     sysdep ();
  1008.     jobclass = hostname;
  1009.     jobtitle = NULL;
  1010.     for (i = 1; i < argc; ++i) {
  1011.     if (*argv[i] == '-')
  1012.         i += option (argv[i], argv[i+1]);
  1013.     else {
  1014.         if (!jobtitle) {
  1015.         char *ptr = strrchr (argv[i], '/');
  1016.         jobtitle = ptr ? ptr + 1 : argv[i];
  1017.         }
  1018.         if (job == NULL && (job = open_job (printer)) == NULL)
  1019.         exit (1);
  1020.         file_args++;
  1021.         if (send_print_file (job, argv[i], file_type)) {
  1022.         files_printed++;
  1023.         if (rflag)
  1024.             mark_for_delete (argv[i]);
  1025.         }
  1026.     }
  1027.     }
  1028.     if (file_args == 0) {
  1029.     if (!jobtitle)
  1030.         jobtitle = "stdin";
  1031.     if ((job = open_job (printer)) == NULL)
  1032.         exit (1);
  1033.     files_printed += send_print_file (job, 0, file_type);
  1034.     }
  1035.     if (files_printed > 0) {
  1036.     if (close_job (job)) {
  1037.         delete_marked_files ();
  1038.         exit (0);
  1039.     }
  1040.     else
  1041.         exit (1);
  1042.     }
  1043.     else
  1044.     exit (1);
  1045.     exit (0);
  1046. }
  1047.