![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to spooler.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / bin / mlp|
Return to spooler.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / bin / mlp |
1.1 root 1: /******************************************************************************
2: Various routines used by the MLP spooler system.
3: ******************************************************************************/
4:
5: #include "header.h"
6:
7: char progname[16];
8:
9: static char caparea[WORKSTR];
10: static char *PS, *PN;
11:
12: char curr_printer[WORKSTR];
13: char curr_device[WORKSTR];
14: char curr_backend[WORKSTR];
15: char curr_desc[WORKSTR];
16: char curr_user[20];
17: char curr_name[20];
18: char curr_longevity[2];
19: int curr_mailme;
20: int curr_writeme;
21: int curr_copies;
22: int curr_copy;
23: int curr_formlen;
24: int abort_write = FALSE;
25: int kill_request = FALSE;
26:
27:
28: /******************************************************************************
29: Scatf works like sprintf except the target string has the newly formated
30: string appended to the end of it. Be sure the target is big enough to
31: hold the new string as well as its current contents. Returns a pointer
32: to the target string.
33: ******************************************************************************/
34:
35: char *scatf( va_alist)
36: va_dcl
37: {
38: va_list args;
39: char *dest, *tmp;
40:
41: tmp = malloc(512);
42: va_start( args);
43:
44: dest = va_arg( args, char *);
45:
46: sprintf( tmp, "%r", args);
47:
48: strcat( dest, tmp);
49:
50: va_end( args);
51: free( tmp);
52:
53: return( dest);
54: }
55:
56:
57:
58: /******************************************************************************
59: fatal. Handles fatal errors with "astonishing" grace. It sends a formated
60: messages to root's mailbox and terminates the program. Warning sends a
61: formated message to the user's mailbox and returns to caller.
62: ******************************************************************************/
63:
64: void warning( va_alist)
65: va_dcl
66: {
67: va_list args;
68: char *i, *j, user[20];
69:
70: strcpy( user, "root"); if ( i = (char *) getlogin()) strcpy( user, i);
71:
72: i = calloc(1024,1); j = calloc(1024,1);
73:
74: strcpy( i, "/bin/echo \"\n`date`\n\"");
75: strcat( i, "'\n*** Message From The MLP Spooler ***\n\n");
76:
77: va_start( args);
78: sprintf( j, "%r", args);
79: va_end( args);
80:
81: strcat( i, j);
82:
83: if (getenv("MLPLMAIL"))
84: strcat( i, "\n\n' | lmail ");
85: else
86: strcat( i, "\n\n' | mail ");
87:
88: strcat( i, user);
89:
90: log( "%s", j); system( i);
91:
92: free( i); free( j);
93: }
94:
95: void warning_user( va_alist)
96: va_dcl
97: {
98: va_list args;
99: char *i, *j, *user;
100:
101: i = calloc(1024,1); j = calloc(1024,1);
102:
103: strcpy( i, "/bin/echo \"\n`date`\n\"");
104: strcat( i, "'\n*** Message From The MLP Spooler ***\n\n");
105:
106: va_start( args);
107: user = va_arg( args, char *); sprintf( j, "%r", args);
108: va_end( args);
109:
110: strcat( i, j);
111:
112: if (getenv("MLPLMAIL"))
113: strcat( i, "\n\n' | lmail ");
114: else
115: strcat( i, "\n\n' | mail ");
116:
117: strcat( i, user);
118:
119: log( "%s", j); system( i);
120:
121: free( i); free( j);
122: }
123:
124:
125:
126: void fatal( va_alist)
127: va_dcl
128: {
129: va_list args;
130: char *i, *j;
131:
132: i = calloc(1024,1); j = calloc(1024,1);
133:
134: strcpy( i, "/bin/echo \"\n`date`\n\"");
135: strcat( i, "'\n*** Message From The MLP Spooler ***\n\n");
136:
137: va_start( args);
138: sprintf( j, "%r", args);
139: va_end( args);
140:
141: strcat( i, j);
142:
143: if (getenv("MLPLMAIL"))
144: strcat( i, "\n\n' | lmail root");
145: else
146: strcat( i, "\n\n' | mail root");
147:
148: log( "%s", j); system( i);
149:
150: free( i); free( j);
151: exit(0);
152: }
153:
154:
155: /******************************************************************************
156: Removes the leading and trailing spaces from the given string. First
157: scan to the end of the string. Then eat the right hand spaces. Then
158: eat the left hand spaces. Then copy the unpadded string back into its
159: original place.
160: ******************************************************************************/
161:
162: char *unpadd( str)
163: char *str;
164: {
165: int len = 0;
166: char *t, *u;
167:
168: for (t = str; *t; t++) len++; t--;
169:
170: while ( t != str && *t == ' ') { *t = 0; t--; len--;}
171:
172: for (t = str; *t && *t == ' '; t++) len--;
173:
174: u = calloc((len+1), 1); strncpy( u, t, len); strcpy( str, u); free( u);
175:
176: return( str);
177: }
178:
179:
180: /******************************************************************************
181: Rename a file.
182: ******************************************************************************/
183:
184: int rename( old, new)
185: char *old;
186: char *new;
187: {
188: unlink( new);
189:
190: if ( link( old, new) == BAD) return(2);
191:
192: if ( unlink( old) == BAD) return(3);
193:
194: return(0);
195: }
196:
197:
198:
199:
200:
201: /*****************************************************************************
202: Put a request in the inactive queue
203: *****************************************************************************/
204:
205: void make_inactive( name)
206: char *name;
207: {
208: char newname[20], path[WORKSTR], newpath[WORKSTR];
209:
210: if (*name == 'r') return; /* already inactive */
211:
212: strcpy( newname, name); newname[0] = 'r';
213:
214: sprintf( path, "%s/%s", QUEUE_PATH, name);
215: sprintf( newpath, "%s/%s", QUEUE_PATH, newname);
216:
217: rename( path, newpath);
218: }
219:
220:
221:
222:
223:
224: /******************************************************************************
225: Get/Set header information
226: ******************************************************************************/
227:
228: char *headerval( header, opt, value)
229: char *header;
230: int opt;
231: char *value;
232: {
233: static char s[HEADER_SIZE];
234: int offset, length, n;
235:
236: switch (opt) {
237: case H_USER: offset = 0; length = 14; break;
238: case H_PRINTER: offset = 14; length = 14; break;
239: case H_TYPE: offset = 28; length = 10; break;
240: case H_FORMLEN: offset = 38; length = 3; break;
241: case H_PAGES: offset = 41; length = 4; break;
242: case H_COPIES: offset = 45; length = 2; break;
243: case H_LONGEVITY: offset = 47; length = 1; break;
244: case H_MAILME: offset = 48; length = 1; break;
245: case H_WRITEME: offset = 49; length = 1; break;
246: case H_DBASE: offset = 50; length = 14; break;
247: case H_FORMAT: offset = 64; length = 14; break;
248: case H_DSTAMP: offset = 78; length = 10; break;
249: case H_DESC: offset = 88; length = 60; break;
250:
251: case H_ENTIRE: offset = 0; length = HEADER_SIZE-2;
252: header[HEADER_SIZE-1] = '\n';
253: header[HEADER_SIZE] = 0;
254: break;
255: }
256:
257: if (value[0]) {
258: for (n = 0; n < length; n++) header[offset+n] = ' ';
259: for (n = 0; value[n] && n < length; n++) header[offset+n] = value[n];
260: }
261:
262: strncpy( s, &header[offset], length); s[length] = 0;
263:
264: return( s);
265: }
266:
267:
268:
269:
270: /******************************************************************************
271: Log text messages into the log file.
272: ******************************************************************************/
273:
274: log( va_alist)
275: va_dcl
276: {
277: va_list args;
278: FILE *fp;
279: long clock;
280: struct tm *tt;
281: char message[1200];
282:
283:
284: va_start( args); sprintf( message, "%r", args); va_end( args);
285:
286: MLP_lock( L_LOG);
287:
288: time( &clock); tt = localtime( &clock);
289:
290: if ( fp = fopen( LOG_PATH, "a+")) {
291: fprintf( fp, "%02d/%02d/%02d ", (tt->tm_mon+1), tt->tm_mday, tt->tm_year);
292: fprintf( fp, "%02d:%02d - ", (tt->tm_hour), tt->tm_min);
293: fprintf( fp, "%s\n", message);
294: fflush( fp);
295: close( fp);
296: }
297:
298: MLP_unlock( L_LOG);
299: }
300:
301:
302:
303: /******************************************************************************
304: Get Termcap Information. If we've already filled PS then don't bother again.
305: ******************************************************************************/
306:
307: void get_termcap()
308: {
309: extern char *tgetstr();
310: extern int tgetent();
311: char *buff, *term, *ptr;
312:
313: if ( PS) return;
314:
315: ptr = buff = calloc( 1024, 1);
316:
317: if ( buff == NULL) fatal("Not enough memory to local print");
318:
319: if ( (term = getenv("TERM")) == NULL)
320: fatal("Trying to local print. TERM must be defined.");
321:
322: if ( tgetent( buff, term) == BAD)
323: fatal("Trying to local print. Cannot find %s in /etc/termcap", term);
324:
325: ptr = caparea;
326:
327: PS = tgetstr( "PS", &ptr);
328: PN = tgetstr( "PN", &ptr);
329:
330: if ( PS == NULL || PN == NULL)
331: fatal("Trying to local print.\n\nBoth PS and PN need to be defined for terminal %s in /etc/termcap", term);
332: }
333:
334:
335:
336:
337:
338:
339:
340: /******************************************************************************
341: Return a datestamp string (actually it is the long-int in text form)
342: ******************************************************************************/
343:
344: char *datestamp()
345: {
346: static char stamp[11];
347: time_t t;
348:
349: time( &t); sprintf( stamp, "%010lu", t);
350:
351: return( stamp);
352: }
353:
354:
355:
356: /******************************************************************************
357: Given a string, convert it to uppercase.
358: ******************************************************************************/
359:
360: char *uppercase( str)
361: char *str;
362: {
363: char *c = str;
364:
365: while (*c) {
366: if (islower(*c)) *c = toupper(*c);
367: c++;
368: }
369:
370: return( str);
371: }
372:
373:
374:
375: /******************************************************************************
376: Given the name of a control-file parameter, return its value. Lock the
377: file so we can read/write it without it changing on us. If the value of the
378: string "newval", is non-null then assign the parameter this new new value.
379: ******************************************************************************/
380:
381: char *parameters( param, newval, pathname, locktype)
382: char *param;
383: char *newval;
384: char *pathname;
385: int locktype;
386: {
387: static char value[ WORKSTR];
388: FILE *fp, *ofp;
389: char tmp[WORKSTR], tmp1[WORKSTR], parameter[30], *c, tmppath[WORKSTR];
390:
391: sprintf( tmppath, "%s.tmp", pathname);
392:
393: strncpy( parameter, param, sizeof( parameter)); uppercase( parameter);
394:
395: strcpy( value, "");
396:
397: MLP_lock( locktype);
398:
399: if ( (fp = fopen( pathname, "r"))) {
400:
401: if (!strcmp( newval, "")) {
402:
403: while (!feof( fp)) {
404: fgets( tmp, sizeof( tmp), fp);
405:
406: for (c = tmp; *c && *c != '#'; c++); /* look for comment */
407:
408: if ( *tmp && !*c) {
409: c = strtok( tmp, SEP); uppercase( c);
410:
411:
412: if ( !strcmp( c, parameter)) {
413: c = strtok( NULL, "\n");
414: while (*c && (*c == ' ' || *c == '\t' || *c == '=')) c++;
415: strcpy( value, c);
416: break;
417: }
418: }
419: }
420: fclose( fp);
421: }
422: else {
423: if ( (ofp = fopen( tmppath, "w"))) {
424:
425: while (!feof( fp)) {
426: fgets( tmp, sizeof( tmp), fp); strcpy( tmp1, tmp);
427:
428: if ( *tmp && *tmp != '#') {
429: c = strtok( tmp, SEP); uppercase( c);
430:
431: if ( strcmp( c, parameter))
432: fprintf( ofp, "%s", tmp1);
433: }
434: else
435: fprintf( ofp, "%s", tmp1);
436: }
437:
438: fprintf( ofp, "%s = %s\n", param, newval);
439:
440: fclose( ofp); fclose( fp);
441:
442: rename( tmppath, pathname);
443: }
444: else {
445: fclose( fp);
446: fatal("Cannot create %s", tmppath);
447: }
448: }
449: }
450: else
451: if ( errno == EACCES)
452: fatal("Permission Problem with \"%s\". It should have the suid bit set.", progname);
453: else
454: if ( rename( tmppath, pathname) == 0) {
455: MLP_unlock( locktype);
456: return( parameters( param, newval, pathname, locktype));
457: }
458: else {
459: if ( (fp = fopen( pathname, "w"))) {
460: fclose( fp);
461: MLP_unlock( locktype);
462: return( parameters( param, newval, pathname, locktype));
463: }
464: else
465: fatal("Cannot create control file: %s", pathname);
466: }
467:
468:
469: MLP_unlock( locktype);
470:
471: return( value);
472: }
473:
474:
475:
476:
477: /******************************************************************************
478: Given the name of a printer-setup parameter, return its value.
479: If the value of the string "newval", is non-null then assign the parameter
480: this new new value.
481: ******************************************************************************/
482:
483: char *controls( param, newval)
484: char *param;
485: char *newval;
486: {
487: return( parameters( param, newval, CONTROL_PATH, L_CONTROL));
488: }
489:
490:
491: /******************************************************************************
492: Given the name of a printer-status parameter, return its value.
493: If the value of the string "newval", is non-null then assign the parameter
494: this new new value.
495: ******************************************************************************/
496:
497: char *status( param, newval)
498: char *param;
499: char *newval;
500: {
501: return( parameters( param, newval, STATUS_PATH, L_STATUS));
502: }
503:
504:
505:
506:
507: /*****************************************************************************
508: Given the name of a printer, return the name of its device. The controls
509: line for a printer looks like this:
510:
511: printer = name, device, backend
512: *****************************************************************************/
513:
514: char *printer_device( newprinter)
515: char *newprinter;
516: {
517: char line[WORKSTR], tmp[40], *c, tmppath[WORKSTR], printer[WORKSTR];
518: FILE *fp;
519:
520: strcpy( printer, newprinter);
521:
522: sprintf( tmppath, "%s.tmp", CONTROL_PATH);
523:
524: MLP_lock( L_CONTROL);
525:
526: if ( (fp = fopen( CONTROL_PATH, "r"))) {
527:
528: while ( fgets( line, sizeof( line), fp)) {
529:
530: *tmp = *curr_device = *curr_backend = 0;
531:
532: c = strtok( line, SEP); if (c) strncpy( tmp, c, sizeof(tmp));
533:
534: if (!strcmp( "PRINTER", uppercase( tmp))) {
535: c = strtok( NULL, SEP);
536:
537: if (!strcmp( printer, c)) {
538: c = strtok( NULL, SEP); if (c) strncpy( curr_device, c, WORKSTR);
539: c = strtok( NULL, SEP); if (c) strncpy( curr_backend, c, WORKSTR);
540: break;
541: }
542: }
543: }
544:
545: fclose( fp);
546: }
547: else
548: if ( errno == EACCES) {
549: /* fprintf(stderr,"permission problem (%s)\n", progname); fflush(stderr); */
550: fatal("Permission Problem with \"%s\". It should have the suid bit set.", progname);
551: }
552: else
553: if ( rename( tmppath, CONTROL_PATH) == 0) {
554: MLP_unlock( L_CONTROL);
555: return( printer_device( newprinter));
556: }
557: else
558: fatal( "Missing control file: %s", CONTROL_PATH);
559:
560: MLP_unlock( L_CONTROL);
561:
562: return( curr_device);
563: }
564:
565:
566:
567:
568:
569: /******************************************************************************
570: Given a user name, return the name of the printer to which they are cur-
571: rently routed.
572: ******************************************************************************/
573:
574: char *route_request( user)
575: char *user;
576: {
577: static char printer[15];
578: FILE *fp;
579: char path[WORKSTR], *c;
580:
581: sprintf( path, "%s/%s", ROUTE_PATH, user);
582:
583:
584: strcpy( printer, "");
585:
586: if ( (fp = fopen( path, "r"))) {
587: fgets( printer, sizeof( printer), fp);
588: fclose( fp);
589: }
590: else {
591: strcpy( printer, controls( DEFAULT,""));
592:
593: if (!strcmp( printer, ""))
594: fatal( "Controls file (%s) needs a default printer entry", CONTROL_PATH);
595: }
596:
597: if ( c = strchr( printer, '\n')) *c = 0;
598:
599: return( printer);
600: }
601:
602:
603:
604:
605:
606: /******************************************************************************
607: Return a new report sequence number.
608: ******************************************************************************/
609:
610: int get_seq_num()
611: {
612: char *v, newnum[10];
613: int n;
614:
615: v = status("seqnum",""); if ( v[0] == 0) v = "00001";
616:
617: sscanf( v, "%d", &n); if ( n >= 32001) n = 1;
618:
619: sprintf( newnum, "%05u", (n+1)); status( SEQNUM, newnum);
620:
621: return(n);
622: }
623:
624:
625:
626:
627: /******************************************************************************
628: Local print. Send the contents of the spool file (less the header)
629: to the printer connected to the user's terminal. We assume that we are
630: positioned past the header.
631: ******************************************************************************/
632:
633: void local_print( fd, start, end)
634: int fd;
635: int start;
636: int end;
637: {
638: char *c, k;
639: long here;
640:
641:
642: here = lseek( fd, 0L, 1);
643:
644: get_termcap();
645:
646: write( 1, PN, strlen( PN));
647:
648: writeOut( fd, 1, start, end, curr_formlen, FALSE);
649:
650: c = controls( LOCALFEED, "");
651:
652: if (!strcmp( c, "ON") || !strcmp( c, "on")) { k = '\f'; write( 1, &k, 1); }
653:
654: write( 1, PS, strlen( PS));
655:
656: lseek( fd, here, 0);
657: }
658:
659:
660:
661: /*****************************************************************************
662: Return a sorted list of the spool queue. The data structure returned is
663: a two dimensional array ( entries x MAXNAMLEN).
664: *****************************************************************************/
665:
666: char *dirlist( dirname, descend)
667: char *dirname;
668: int descend;
669: {
670: extern char *realloc();
671: DIR *dr;
672: struct dirent *dp;
673: char *t, tmp[MAXNAMLEN];
674: int size, top, swapit, i, j, gap, comp;
675:
676: dr = opendir( dirname); t = calloc( MAXNAMLEN, 1); size = 0;
677:
678: while ( ( dp = readdir( dr)) != NULL)
679: if (!strcmp( ".", dp->d_name) || !strcmp( "..", dp->d_name))
680: continue;
681: else {
682: strncpy( (t+(size * MAXNAMLEN)), dp->d_name, MAXNAMLEN);
683: size++;
684: t = realloc( t, ((size+1) * MAXNAMLEN));
685: }
686:
687: closedir( dr);
688:
689: strcpy( (t+(size * MAXNAMLEN)), "");
690:
691:
692: /* Use a COMBsort to sort the items in this directory */
693: /* This sort is like a bubble sort only MUCH faster */
694:
695: gap = size;
696:
697: do {
698: gap = gap * 10 / 13; if (gap == 0) gap = 1;
699:
700: top = size - gap; swapit = 0;
701:
702: for ( i = 0; i < top; i++) {
703: j = i + gap;
704:
705: comp = strcmp( (t+(i * MAXNAMLEN)), (t+(j * MAXNAMLEN)));
706:
707: if (descend) { /* Reverse the sort order */
708: if ( comp > 0)
709: comp = 0;
710: else
711: comp = 1;
712: }
713:
714: if ( comp > 0) {
715: strcpy( tmp, (t+(i * MAXNAMLEN)));
716: strcpy( (t+(i * MAXNAMLEN)), (t+(j * MAXNAMLEN)));
717: strcpy( (t+(j * MAXNAMLEN)), tmp);
718:
719: swapit++;
720: }
721: }
722: } while ( swapit || gap > 1);
723: return( t);
724: }
725:
726:
727:
728: /******************************************************************************
729: Wakeup The Despooler by sending it an alarm signal. The despooler's PID
730: will be found in the controls database.
731: ******************************************************************************/
732:
733: void wakeup_despooler()
734: {
735: char *v;
736: int pid = 0;
737:
738: v = status( DESPOOLER,"");
739:
740: sscanf( v, "%d", &pid);
741:
742: if ( pid > 0) kill( pid, SIGALRM);
743: }
744:
745:
746:
747:
748:
749: /******************************************************************************
750: Basename. Strip the leading path information from a pathname.
751: ******************************************************************************/
752:
753: char *basename( path)
754: char *path;
755: {
756: char *c;
757:
758: if (path == NULL) return("");
759:
760: for (c = path; *c; c++); c--; /* go to the end of the string */
761:
762: while (c != path && *(c-1) != '/') c--; /* step back til we see a slash */
763:
764: return( c);
765: }
766:
767:
768:
769:
770: /******************************************************************************
771: Return TRUE if the scheduler is running, FALSE if not.
772: ******************************************************************************/
773:
774: int scheduler_status()
775: {
776: char *t;
777: int pid;
778:
779: t = status( DESPOOLER, ""); sscanf( t, "%d", &pid);
780:
781: if ( pid > 1 && !kill( pid, 0))
782: return( TRUE);
783: else
784: return( FALSE);
785: }
786:
787:
788:
789:
790: /******************************************************************************
791: This routine does all the actual I/O to the device. The tricky part is
792: counting the pages and (optionally printing only the desired range of pages).
793: It is used in several places. Source and Sink are the input and output
794: file descriptors. The source's file pointer is expected to be at the
795: start of the user's data; that is, seek past the header, if there is one.
796: Start and end are the starting and ending page numbers for the reqeuest.
797: If both of these are zero then we will send all of the source data to the
798: sink, otherwise we send source to sink only when we are within the page
799: range. Counting pages depends heavily on the form length (curr_formlen)
800: and the nature of the source data. If you are sending bitmaps to a laser
801: printer though this routine, the page numbers will probably be wildly
802: skewed! At this point, I know of no convienent way around this. You'd
803: have to parse the input for ALL known laser printers. Then the next new
804: one could possibly make your effort moot. Maybe this could be done for
805: HPCL and Postscript? If the flag "report" is TRUE then the routine's
806: progress will be reported in the status file. This routine returns the
807: number of pages that it has processed.
808: ******************************************************************************/
809:
810: #define IOBUFF 1024
811:
812: int writeOut( source, sink, start, end, formlen, report)
813: int source;
814: int sink;
815: int start;
816: int end;
817: int formlen;
818: int report;
819: {
820: int result, lines, progress;
821: int pages;
822: long rsize, oldpos;
823: char tmp[WORKSTR];
824: char *i, *ibuff, *imax; /* input buffer pointers */
825: char *o, *obuff, *omax; /* output buffer pointers */
826:
827: /* how big is the source file? */
828:
829: oldpos = lseek( source, 0L, 1);
830: rsize = lseek( source, 0L, 2); lseek( source, oldpos, 0);
831:
832:
833: ibuff = malloc( IOBUFF); obuff = malloc( IOBUFF);
834:
835: o = obuff; omax = obuff + IOBUFF;
836:
837: lines = 0; pages = 1;
838:
839: while ( result = read( source, ibuff, IOBUFF)) {
840: if (abort_write) {
841: o = obuff;
842: pages = -1;
843: break;
844: }
845:
846: if ( start == 0 && end == 0)
847: write( sink, ibuff, result); /* print entire request */
848: else {
849:
850: /* print from start to end page of request */
851:
852: for ( i = ibuff, imax = ibuff + result; i < imax; i++) {
853:
854: if ( *i == '\n') {
855: lines++;
856:
857: if ( lines > formlen) {
858: lines = 0;
859: /* lines -= formlen; */
860: pages++;
861: }
862: }
863: else
864: if ( *i == '\f') {
865: pages++;
866: lines = 0;
867: }
868:
869: if ( pages >= start && pages <= end) {
870:
871: *o++ = *i;
872:
873: if ( o >= omax) {
874:
875: write( sink, obuff, IOBUFF);
876: o = obuff;
877: }
878: }
879: }
880: }
881:
882:
883: /* Report Progress to the status file */
884:
885: if (report) {
886: progress = (int) (lseek( source, 0L, 1) * 100L / rsize);
887:
888: sprintf( tmp, "%d, %s, %s, %d, %d of %d", getpid(), curr_name,
889: curr_printer, progress, curr_copy, curr_copies);
890:
891: status( curr_device, tmp);
892: }
893: }
894:
895: /* write anything leftover in the output buffer */
896:
897: if ( o != obuff) write( sink, obuff, (int) (o - obuff));
898:
899:
900: free( ibuff); free( obuff);
901:
902: return( pages);
903: }
904:
905:
906:
907: /******************************************************************************
908: Given the sequence number of a request, return the full file name of
909: the request.
910: ******************************************************************************/
911:
912: char *request_name( seqnum)
913: char *seqnum;
914: {
915: DIR *dr;
916: struct dirent *dp;
917: int val;
918: char tvalue[15];
919: static char value[15];
920:
921:
922: val = 0; sscanf( seqnum, "%d", &val); sprintf( tvalue, "%05u", val);
923:
924: dr = opendir( QUEUE_PATH); value[0] = 0;
925:
926:
927: while ( ( dp = readdir( dr)) != NULL)
928: if (!strcmp( ".", dp->d_name) || !strcmp( "..", dp->d_name))
929: continue;
930: else {
931: if (!strncmp( tvalue, &dp->d_name[2], 5)) {
932: sprintf( value, "%s", dp->d_name);
933: break;
934: }
935: }
936:
937: closedir( dr);
938:
939: return( value);
940: }
941:
942:
943:
944:
945: /****************************************************************************
946: Given the report sequence number, return the owner's name
947: ****************************************************************************/
948:
949: char *request_owner( seqnum)
950: char *seqnum;
951: {
952: static char owner[20];
953: char path[WORKSTR], head[HEADER_SIZE];
954: int fd;
955:
956: strcpy( owner, request_name( seqnum));
957:
958: if (*owner) {
959: sprintf( path, "%s/%s", QUEUE_PATH, owner);
960:
961: if ( (fd = open( path, O_RDONLY)) != BAD) {
962: read( fd, head, HEADER_SIZE);
963: close( fd);
964:
965: strcpy( owner, headerval( head, H_USER, ""));
966: unpadd( owner);
967: }
968: }
969: else
970: *owner = 0;
971:
972: return( owner);
973: }
974:
975:
976:
977:
978: /****************************************************************************
979: Return 1 if I (the program's user) own the request, 0 otherwise. If I'm
980: superuser, then I own it all.
981: ****************************************************************************/
982:
983: int do_i_own_it( seqnum)
984: char *seqnum;
985: {
986: struct passwd *p;
987:
988: p = getpwuid( getuid());
989:
990: if ((p && !strcmp( p->pw_name, request_owner( seqnum))) ||
991: (getuid() == 0))
992: return(1);
993: else
994: return(0);
995: }
996:
997:
998:
999:
1000:
1001: /******************************************************************************
1002: Report the status of all the printers defined in the control file.
1003: ******************************************************************************/
1004:
1005: char *each_printer( command)
1006: int command;
1007: {
1008: static FILE *fp;
1009: static char line[WORKSTR];
1010: char tmp[WORKSTR], *t;
1011:
1012: *line = 0;
1013:
1014: switch (command) {
1015: case E_START: MLP_lock( L_CONTROL);
1016:
1017: if ( (fp = fopen( CONTROL_PATH, "r+")) == NULL) {
1018: sprintf( tmp, "%s.tmp", CONTROL_PATH);
1019:
1020: if ( errno == EACCES)
1021: fatal("Permission Problem with \"%s\". It should have the suid bit set.", progname);
1022: else
1023: if ( rename( tmp, CONTROL_PATH) == 0) {
1024: MLP_unlock( L_CONTROL);
1025: return( each_printer( command));
1026: }
1027: else
1028: fatal( "Missing control file: %s", CONTROL_PATH);
1029: }
1030: break;
1031:
1032: case E_NEXT: while (fgets( tmp, sizeof(tmp), fp)) {
1033:
1034: t = strtok( tmp, SEP); uppercase( t);
1035: if (!strcmp( "PRINTER", t)) {
1036: for (t = tmp; *t; t++); t++;
1037: while (strchr(SEP, *t)) t++;
1038: strcpy( line, t);
1039: break;
1040: }
1041: }
1042: break;
1043:
1044: case E_REWIND: fseek( fp, 0L, SEEK_SET); break;
1045:
1046: case E_END: fclose( fp);
1047: case E_UNLOCK: MLP_unlock( L_CONTROL); break;
1048:
1049: case E_FILE: return( (char *) fp);
1050: }
1051:
1052: return( line);
1053: }
1054:
1055:
1056:
1057:
1058: char *report_printer_status( display_type)
1059: {
1060: static char request_list[WORKSTR];
1061: int pid, req;
1062: char tmp[40], *t, *c, *d, *header, rpath[WORKSTR];
1063: char request[20], user[20], timestr[40];
1064: long rtime;
1065:
1066: request_list[0] = 0; /* will contain a list of all the request that are
1067: currently printing. This is so we can skip these
1068: when we go over the list of all pending requests.*/
1069:
1070:
1071: each_printer( E_START);
1072:
1073: while ( *(t = each_printer( E_NEXT))) {
1074:
1075: *tmp = *curr_printer = *curr_device = *curr_backend = 0;
1076:
1077: c = strtok( t , SEP); if (c) strncpy( curr_printer, c, WORKSTR);
1078: c = strtok( NULL, SEP); if (c) strncpy( curr_device, c, WORKSTR);
1079: c = strtok( NULL, SEP); if (c) strncpy( curr_backend, c, WORKSTR);
1080:
1081:
1082: /*** Now look at this printer from the status database ***/
1083:
1084: strcpy( tmp, status( curr_device, ""));
1085:
1086:
1087: c = strtok( tmp, SEP); pid = 0; sscanf( c, "%d", &pid);
1088:
1089: if (pid > 0 && kill( pid, 0)) c = NULL;
1090:
1091: switch (display_type) {
1092: case PID_DISPLAY:
1093: if (c != NULL) {
1094: c = strtok( NULL, SEP);
1095: if (c) sprintf( timestr, "%d|%s ", pid, (c+2));
1096:
1097: if ((strlen( request_list)+strlen( timestr))
1098: < sizeof( request_list))
1099: strcat( request_list, timestr);
1100: }
1101: break;
1102:
1103: case DEVICE_DISPLAY:
1104: printf("device for %s: %s\n", curr_printer, curr_device);
1105: break;
1106:
1107: case PRINTER_DISPLAY:
1108: *request = 0; if ( d = strtok( NULL, SEP)) strcpy( request, d);
1109:
1110: d = strtok( NULL, SEP);
1111:
1112: if ( c == NULL || d == NULL || strcmp(d, curr_printer))
1113: printf("printer %s is idle\n", curr_printer);
1114: else {
1115: printf("printer %s is printing request #", curr_printer);
1116: printf("%s, ", &request[2]);
1117:
1118: if ( c = strtok( NULL, SEP))
1119: printf("%s%% sent to device", c);
1120:
1121: if ( c = strtok( NULL, ","))
1122: printf(", copy %s", c);
1123:
1124: printf("\n");
1125: }
1126: break;
1127:
1128: case REQUEST_DISPLAY:
1129: if ( c != NULL) {
1130: strcpy( request, strtok( NULL, SEP));
1131: sprintf( rpath, "%s/%s", QUEUE_PATH, request);
1132:
1133: if ((c = strtok( NULL, SEP)) && !strcpy( c, curr_printer)) {
1134:
1135: if ( (req = open( rpath, O_RDONLY)) != BAD) {
1136: header = calloc( HEADER_SIZE, 1);
1137: read( req, header, HEADER_SIZE);
1138: close( req);
1139:
1140: strcpy( user, headerval( header, H_USER, ""));
1141: unpadd( user);
1142:
1143: strcpy( timestr, headerval( header, H_DSTAMP, ""));
1144: rtime = 0L; sscanf( timestr, "%ld", &rtime);
1145: strcpy( timestr, ctime(&rtime));
1146: timestr[strlen(timestr)-1] = 0;
1147:
1148: free( header);
1149:
1150: printf( "%s-%s\t\t%c\t%s", user,
1151: (request+2), *(request+1), timestr);
1152:
1153: printf( "\ton %s\n", curr_printer);
1154:
1155:
1156: sprintf( timestr, "%s|", request);
1157: if ((strlen( request_list)+strlen( timestr))
1158: < sizeof( request_list))
1159: strcat( request_list, timestr);
1160: }
1161: }
1162: }
1163:
1164: break;
1165: }
1166: }
1167:
1168: each_printer( E_END);
1169:
1170: return( request_list);
1171: }
1172:
1173:
1174:
1175: /******************************************************************************
1176: Cancel currently printing requests (not pending ones!). Kill only the ones
1177: I own. If I'm superuser, then I own it all.
1178: ******************************************************************************/
1179:
1180: int kill_printing_request( seqnum, sig, flag)
1181: int seqnum;
1182: int sig;
1183: int flag;
1184: {
1185: int pid, seq, sucessfull = FALSE;
1186: char *list, *t;
1187:
1188: list = report_printer_status( PID_DISPLAY);
1189:
1190: t = strtok( list, " ");
1191:
1192: do {
1193: if (t) {
1194: sscanf( t, "%d|%d", &pid, &seq);
1195:
1196: if ( flag || (seq == seqnum))
1197: if (do_i_own_it( seqnum)) {
1198: kill( pid, sig);
1199: sucessfull = TRUE;
1200: }
1201:
1202: t = strtok( NULL, " ");
1203: }
1204: } while (t);
1205:
1206: if (flag) log("Abort Currently Printing Requests");
1207:
1208: return( sucessfull);
1209: }
1210:
1211:
1212:
1213:
1214: /*****************************************************************************
1215: This routine scans the spool queue looking for request that need to be
1216: removed. That is, they need to die of old age! There are four classes
1217: of longevity: (R) reprint, (T) temporary, (S) shortterm, and (L) longterm.
1218: R requests are really just headers and they are deleted as soon as they
1219: have despooled. This routine handles the other three classes.
1220: *****************************************************************************/
1221:
1222: #define THOURS 0.5
1223: #define SHOURS 24.0
1224: #define LHOURS (7.0 * 24.0)
1225:
1226: void grim_reaper()
1227: {
1228: long temporary, shortterm, longterm, current, dstamp, elapst;
1229: float thours, shours, lhours;
1230: char *entries, *name, header[HEADER_SIZE], path[WORKSTR], life[2];
1231: char desc[WORKSTR];
1232: int n, fd, die;
1233:
1234: thours = THOURS; sscanf( controls( TLIFE, ""), "%f", &thours);
1235: shours = SHOURS; sscanf( controls( SLIFE, ""), "%f", &shours);
1236: lhours = LHOURS; sscanf( controls( LLIFE, ""), "%f", &lhours);
1237:
1238: temporary = (long) 3600.0 * thours;
1239: shortterm = (long) 3600.0 * shours;
1240: longterm = (long) 3600.0 * lhours;
1241:
1242: time( ¤t);
1243:
1244: entries = dirlist( QUEUE_PATH, FALSE); /* return sorted spool queue list */
1245: /* This list is a two dimensional */
1246: /* array (entries x MAXNAMLEN) */
1247: /* Ascending order */
1248:
1249: for ( n = 0; *(name = (entries+(n * MAXNAMLEN))); n++) {
1250: if ( *name == 'R') continue;
1251:
1252: sprintf( path, "%s/%s", QUEUE_PATH, name);
1253:
1254: if ( fd = open( path, O_RDONLY)) {
1255: read( fd, header, HEADER_SIZE);
1256: dstamp = 0L;
1257: sscanf( headerval( header, H_DSTAMP, ""), "%ld", &dstamp);
1258: sscanf( headerval( header, H_LONGEVITY, ""), "%1s", life);
1259: strcpy( desc, headerval( header, H_DESC, ""));
1260: unpadd( desc);
1261: close( fd);
1262:
1263: elapst = current - dstamp; die = FALSE;
1264:
1265: switch (*life) {
1266: case 'T': if (elapst > temporary) die = TRUE; break;
1267: case 'S': if (elapst > shortterm) die = TRUE; break;
1268: case 'L': if (elapst > longterm) die = TRUE; break;
1269: }
1270:
1271: if (die) {
1272: log( "Request #%s \"%s\" expired.", &name[2], desc);
1273: unlink( path);
1274: /* printf("unlink %s\n", path); */
1275: }
1276: }
1277: }
1278:
1279: free( entries);
1280: }
1281:
1282:
1283:
1284: /******************************************************************************
1285: ftok() implements Unix's function of the same name. Given a valid pathname
1286: and a project identifier, return a "unique" handle. This handle is used by
1287: the Unix IPC. If the path is not found, a -1 is returned. For some reason,
1288: Coherent does not implement this function.
1289: ******************************************************************************/
1290:
1291: key_t ftok( path, proj)
1292: char *path;
1293: char proj;
1294: {
1295: struct stat s;
1296:
1297: if (stat( path, &s) == BAD) return( (key_t) -1L);
1298:
1299: return( (key_t) (s.st_ino | (proj << 16) | (s.st_dev << 24)));
1300: }
1301:
1302:
1303: /******************************************************************************
1304: MLP_Lock. This routine can lock several critical sections involving MLP
1305: process. These are: Cancel, Controls and Status. The controls and status
1306: files need to be locked while they are modified. The Cancel lock keeps
1307: processes that cancel requests out of the hair of the despooler and vice-
1308: versa.
1309:
1310: ***NOTE***
1311: Because Mark Williams has not implemented SEM_UNDO, we will fall back to
1312: lockfiles for safety reasons.
1313: ******************************************************************************/
1314:
1315: int locks[IPC_SEMS]; /* contains lockfile fd's */
1316:
1317: void MLP_lock( which)
1318: int which;
1319: {
1320: char path[WORKSTR];
1321:
1322: sprintf( path, "%s/LCK..%d", QUEUE_PATH, which);
1323:
1324: locks[which] = open( path, O_RDWR); lockf( locks[which], F_LOCK, 0L);
1325:
1326: /* SEM_UNDO is not yet implemented...
1327:
1328: static struct sembuf lcancel[2] = { 0,0,0, 0,1,SEM_UNDO };
1329: static struct sembuf lcontrol[2] = { 1,0,0, 1,1,SEM_UNDO };
1330: static struct sembuf lstatus[2] = { 2,0,0, 2,1,SEM_UNDO };
1331: static struct sembuf llog[2] = { 3,0,0, 3,1,SEM_UNDO };
1332:
1333: struct sembuf *s;
1334: key_t k;
1335: int sID;
1336:
1337: k = ftok( IPC_NAME, 1);
1338:
1339: if ((sID = semget( k, IPC_SEMS, IPC_PERMS|IPC_CREAT|IPC_EXCL)) == BAD) {
1340: if ((sID = semget( k, IPC_SEMS, 0)) == BAD) {
1341: return;
1342: }
1343: }
1344:
1345: switch (which) {
1346: case L_CANCEL: semop( sID, lcancel, 2); break;
1347: case L_CONTROL: semop( sID, lcontrol, 2); break;
1348: case L_STATUS: semop( sID, lstatus, 2); break;
1349: case L_LOG: semop( sID, llog, 2); break;
1350: }
1351: */
1352: }
1353:
1354:
1355:
1356: void MLP_unlock( which)
1357: int which;
1358: {
1359: char path[WORKSTR];
1360:
1361: sprintf( path, "%s/LCK..%d", QUEUE_PATH, which);
1362:
1363: lockf( locks[which], F_ULOCK, 0L); close( locks[which]); unlink( path);
1364:
1365: /* SEM_UNDO is not yet implemented...
1366:
1367: static struct sembuf lcancel[1] = { 0,-1, IPC_NOWAIT|SEM_UNDO };
1368: static struct sembuf lcontrol[1] = { 1,-1, IPC_NOWAIT|SEM_UNDO };
1369: static struct sembuf lstatus[1] = { 2,-1, IPC_NOWAIT|SEM_UNDO };
1370: static struct sembuf llog[1] = { 3,-1, IPC_NOWAIT|SEM_UNDO };
1371:
1372: key_t k;
1373: int sID;
1374:
1375: k = ftok( IPC_NAME, 1);
1376:
1377: if ((sID = semget( k, IPC_SEMS, IPC_PERMS|IPC_CREAT|IPC_EXCL)) == BAD) {
1378: if ((sID = semget( k, IPC_SEMS, 0)) == BAD) {
1379: return;
1380: }
1381: }
1382:
1383: switch (which) {
1384: case L_CANCEL: semop( sID, lcancel, 1); break;
1385: case L_CONTROL: semop( sID, lcontrol, 1); break;
1386: case L_STATUS: semop( sID, lstatus, 1); break;
1387: case L_LOG: semop( sID, llog, 1); break;
1388: }
1389: */
1390: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.