Return to slowsend.c CVS log

Up to [Research Unix] / researchv10no / cmd / postscript / postio

Annotation of researchv10no/cmd/postscript/postio/slowsend.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  *
                      3:  * Stuff that slows the transmission of jobs to PostScript printers. ONLY use it
                      4:  * if you appear to be having trouble with flow control. The idea is simple - only
                      5:  * send a significant amount of data when we're certain the printer is in the
                      6:  * WAITING state. Depends on receiving status messages and only works when the
                      7:  * program is run as a single process. What's done should stop printer generated
                      8:  * XOFFs - provided our input buffer (ie. blocksize) is sufficiently small. Was
                      9:  * originally included in the postio.tmp directory, but can now be requested with
                     10:  * the -S option. Considered eliminating this code, but some printers still depend
                     11:  * on it. In particular Datakit connections made using Datakit PVCs and DACUs seem
                     12:  * to have the most problems. Much of the new stuff that was added can't work when
                     13:  * you use this code and will be automatically disabled.
                     14:  *
                     15:  */
                     16: 
                     17: #include <stdio.h>
                     18: 
                     19: #include "gen.h"
                     20: #include "postio.h"
                     21: 
                     22: extern char    *block;
                     23: extern int     blocksize;
                     24: extern int     head;
                     25: extern int     tail;
                     26: extern char    *line;
                     27: extern char    mesg[];
                     28: extern int     ttyo;
                     29: 
                     30: /*****************************************************************************/
                     31: 
                     32: slowsend(fd_in)
                     33: 
                     34:     int                fd_in;                  /* next input file */
                     35: 
                     36: {
                     37: 
                     38: /*
                     39:  *
                     40:  * A slow version of send() that's very careful about when data is sent to the
                     41:  * printer. Should help prevent overflowing the printer's input buffer, provided
                     42:  * blocksize is sufficiently small (1024 should be safe). It's a totally kludged
                     43:  * up routine that should ONLY be used if you have constant transmission problems.
                     44:  * There's really no way it will be able to drive a printer much faster that about
                     45:  * six pages a minute, even for the simplest jobs. Get it by using the -S option.
                     46:  *
                     47:  */
                     48: 
                     49:     while ( readblock(fd_in) )
                     50:        switch ( getstatus(0) )  {
                     51:            case WAITING:
                     52:                    writeblock(blocksize);
                     53:                    break;
                     54: 
                     55:            case BUSY:
                     56:            case IDLE:
                     57:            case PRINTING:
                     58:                    writeblock(30);
                     59:                    break;
                     60: 
                     61:            case NOSTATUS:
                     62:            case UNKNOWN:
                     63:                    break;
                     64: 
                     65:            case PRINTERERROR:
                     66:                    sleep(30);
                     67:                    break;
                     68: 
                     69:            case ERROR:
                     70:                    fprintf(stderr, "%s", mesg);        /* for csw */
                     71:                    error(FATAL, "PostScript Error");
                     72:                    break;
                     73: 
                     74:            case FLUSHING:
                     75:                    error(FATAL, "Flushing Job");
                     76:                    break;
                     77: 
                     78:            case DISCONNECT:
                     79:                    error(FATAL, "Disconnected - printer may be offline");
                     80:                    break;
                     81: 
                     82:            default:
                     83:                    sleep(2);
                     84:                    break;
                     85:        }   /* End switch */
                     86: 
                     87: }   /* End of send */
                     88: 
                     89: /*****************************************************************************/
                     90: 
                     91: static writeblock(num)
                     92: 
                     93:     int                num;                    /* most bytes we'll write */
                     94: 
                     95: {
                     96: 
                     97:     int                count;                  /* bytes successfully written */
                     98: 
                     99: /*
                    100:  *
                    101:  * Called from send() when it's OK to send the next block to the printer. head
                    102:  * is adjusted after the write, and the number of bytes that were successfully
                    103:  * written is returned to the caller.
                    104:  *
                    105:  */
                    106: 
                    107:     if ( num > tail - head )
                    108:        num = tail - head;
                    109: 
                    110:     if ( (count = write(ttyo, &block[head], num)) == -1 )
                    111:        error(FATAL, "error writing to %s", line);
                    112:     else if ( count == 0 )
                    113:        error(FATAL, "printer appears to be offline");
                    114: 
                    115:     head += count;
                    116:     return(count);
                    117: 
                    118: }   /* End of writeblock */
                    119: 
                    120: /*****************************************************************************/
                    121: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.