?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r19695: update release notes some more and fix a few typos
[Samba.git] / source / printing / lpq_parse.c
blob100585637ae15d4d74fc180a3a603c081ee26787
1 /*
2 Unix SMB/CIFS implementation.
3 lpq parsing routines
4 Copyright (C) Andrew Tridgell 2000
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
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
21 #include "includes.h"
22
23 static const char *Months[13] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
24 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", "Err"};
25
26
27 /*******************************************************************
28 Process time fields
29 ********************************************************************/
30
31 static time_t EntryTime(fstring tok[], int ptr, int count, int minimum)
32 {
33 time_t jobtime,jobtime1;
34
35 jobtime = time(NULL); /* default case: take current time */
36 if (count >= minimum) {
37 struct tm *t;
38 int i, day, hour, min, sec;
39 char *c;
40
41 for (i=0; i<13; i++) {
42 if (!strncmp(tok[ptr], Months[i],3)) {
43 break; /* Find month */
44 }
45 }
46
47 if (i<12) {
48 t = localtime(&jobtime);
49 if (!t) {
50 return (time_t)-1;
51 }
52 day = atoi(tok[ptr+1]);
53 c=(char *)(tok[ptr+2]);
54 *(c+2)=0;
55 hour = atoi(c);
56 *(c+5)=0;
57 min = atoi(c+3);
58 if(*(c+6) != 0) {
59 sec = atoi(c+6);
60 } else {
61 sec=0;
62 }
63
64 if ((t->tm_mon < i)|| ((t->tm_mon == i)&&
65 ((t->tm_mday < day)||
66 ((t->tm_mday == day)&&
67 (t->tm_hour*60+t->tm_min < hour*60+min))))) {
68 t->tm_year--; /* last year's print job */
69 }
70
71 t->tm_mon = i;
72 t->tm_mday = day;
73 t->tm_hour = hour;
74 t->tm_min = min;
75 t->tm_sec = sec;
76 jobtime1 = mktime(t);
77 if (jobtime1 != (time_t)-1) {
78 jobtime = jobtime1;
79 }
80 }
81 }
82 return jobtime;
83 }
84
85 /****************************************************************************
86 parse a lpq line
87
88 here is an example of lpq output under bsd
89
90 Warning: no daemon present
91 Rank Owner Job Files Total Size
92 1st tridge 148 README 8096 bytes
93
94 here is an example of lpq output under osf/1
95
96 Warning: no daemon present
97 Rank Pri Owner Job Files Total Size
98 1st 0 tridge 148 README 8096 bytes
99
100
101 <allan@umich.edu> June 30, 1998.
102 Modified to handle file names with spaces, like the parse_lpq_lprng code
103 further below.
104 ****************************************************************************/
105
106 static BOOL parse_lpq_bsd(char *line,print_queue_struct *buf,BOOL first)
107 {
108 #ifdef OSF1
109 #define RANKTOK 0
110 #define PRIOTOK 1
111 #define USERTOK 2
112 #define JOBTOK 3
113 #define FILETOK 4
114 #define TOTALTOK (count - 2)
115 #define NTOK 6
116 #define MAXTOK 128
117 #else /* OSF1 */
118 #define RANKTOK 0
119 #define USERTOK 1
120 #define JOBTOK 2
121 #define FILETOK 3
122 #define TOTALTOK (count - 2)
123 #define NTOK 5
124 #define MAXTOK 128
125 #endif /* OSF1 */
126
127 char *tok[MAXTOK];
128 int count = 0;
129 pstring line2;
130
131 pstrcpy(line2,line);
132
133 #ifdef OSF1
134 {
135 size_t length;
136 length = strlen(line2);
137 if (line2[length-3] == ':') {
138 return False;
139 }
140 }
141 #endif /* OSF1 */
142
143 /* FIXME: Use next_token rather than strtok! */
144 tok[0] = strtok(line2," \t");
145 count++;
146
147 while ((count < MAXTOK) && ((tok[count] = strtok(NULL," \t")) != NULL)) {
148 count++;
149 }
150
151 /* we must get at least NTOK tokens */
152 if (count < NTOK) {
153 return False;
154 }
155
156 /* the Job and Total columns must be integer */
157 if (!isdigit((int)*tok[JOBTOK]) || !isdigit((int)*tok[TOTALTOK])) {
158 return False;
159 }
160
161 buf->job = atoi(tok[JOBTOK]);
162 buf->size = atoi(tok[TOTALTOK]);
163 buf->status = strequal(tok[RANKTOK],"active")?LPQ_PRINTING:LPQ_QUEUED;
164 buf->time = time(NULL);
165 fstrcpy(buf->fs_user,tok[USERTOK]);
166 fstrcpy(buf->fs_file,tok[FILETOK]);
167
168 if ((FILETOK + 1) != TOTALTOK) {
169 int i;
170
171 for (i = (FILETOK + 1); i < TOTALTOK; i++) {
172 /* FIXME: Using fstrcat rather than other means is a bit
173 * inefficient; this might be a problem for enormous queues with
174 * many fields. */
175 fstrcat(buf->fs_file, " ");
176 fstrcat(buf->fs_file, tok[i]);
177 }
178 /* Ensure null termination. */
179 fstrterminate(buf->fs_file);
180 }
181
182 #ifdef PRIOTOK
183 buf->priority = atoi(tok[PRIOTOK]);
184 #else
185 buf->priority = 1;
186 #endif
187 return True;
188 }
189
190 /*
191 <magnus@hum.auc.dk>
192 LPRng_time modifies the current date by inserting the hour and minute from
193 the lpq output. The lpq time looks like "23:15:07"
194
195 <allan@umich.edu> June 30, 1998.
196 Modified to work with the re-written parse_lpq_lprng routine.
197
198 <J.P.M.v.Itegem@tue.nl> Dec 17,1999
199 Modified to work with lprng 3.16
200 With lprng 3.16 The lpq time looks like
201 "23:15:07"
202 "23:15:07.100"
203 "1999-12-16-23:15:07"
204 "1999-12-16-23:15:07.100"
205
206 */
207 static time_t LPRng_time(char *time_string)
208 {
209 time_t jobtime;
210 struct tm *t;
211
212 jobtime = time(NULL); /* default case: take current time */
213 t = localtime(&jobtime);
214 if (!t) {
215 return (time_t)-1;
216 }
217
218 if ( atoi(time_string) < 24 ){
219 t->tm_hour = atoi(time_string);
220 t->tm_min = atoi(time_string+3);
221 t->tm_sec = atoi(time_string+6);
222 } else {
223 t->tm_year = atoi(time_string)-1900;
224 t->tm_mon = atoi(time_string+5)-1;
225 t->tm_mday = atoi(time_string+8);
226 t->tm_hour = atoi(time_string+11);
227 t->tm_min = atoi(time_string+14);
228 t->tm_sec = atoi(time_string+17);
229 }
230 jobtime = mktime(t);
231
232 return jobtime;
233 }
234
235 /****************************************************************************
236 parse a lprng lpq line
237 <allan@umich.edu> June 30, 1998.
238 Re-wrote this to handle file names with spaces, multiple file names on one
239 lpq line, etc;
240
241 ****************************************************************************/
242
243 static BOOL parse_lpq_lprng(char *line,print_queue_struct *buf,BOOL first)
244 {
245 #define LPRNG_RANKTOK 0
246 #define LPRNG_USERTOK 1
247 #define LPRNG_PRIOTOK 2
248 #define LPRNG_JOBTOK 3
249 #define LPRNG_FILETOK 4
250 #define LPRNG_TOTALTOK (num_tok - 2)
251 #define LPRNG_TIMETOK (num_tok - 1)
252 #define LPRNG_NTOK 7
253 #define LPRNG_MAXTOK 128 /* PFMA just to keep us from running away. */
254
255 fstring tokarr[LPRNG_MAXTOK];
256 const char *cptr;
257 char *ptr;
258 int num_tok = 0;
259
260 cptr = line;
261 while((num_tok < LPRNG_MAXTOK) && next_token( &cptr, tokarr[num_tok], " \t", sizeof(fstring))) {
262 num_tok++;
263 }
264
265 /* We must get at least LPRNG_NTOK tokens. */
266 if (num_tok < LPRNG_NTOK) {
267 return False;
268 }
269
270 if (!isdigit((int)*tokarr[LPRNG_JOBTOK]) || !isdigit((int)*tokarr[LPRNG_TOTALTOK])) {
271 return False;
272 }
273
274 buf->job = atoi(tokarr[LPRNG_JOBTOK]);
275 buf->size = atoi(tokarr[LPRNG_TOTALTOK]);
276
277 if (strequal(tokarr[LPRNG_RANKTOK],"active")) {
278 buf->status = LPQ_PRINTING;
279 } else if (strequal(tokarr[LPRNG_RANKTOK],"done")) {
280 buf->status = LPQ_PRINTED;
281 } else if (isdigit((int)*tokarr[LPRNG_RANKTOK])) {
282 buf->status = LPQ_QUEUED;
283 } else {
284 buf->status = LPQ_PAUSED;
285 }
286
287 buf->priority = *tokarr[LPRNG_PRIOTOK] -'A';
288
289 buf->time = LPRng_time(tokarr[LPRNG_TIMETOK]);
290
291 fstrcpy(buf->fs_user,tokarr[LPRNG_USERTOK]);
292
293 /* The '@hostname' prevents windows from displaying the printing icon
294 * for the current user on the taskbar. Plop in a null.
295 */
296
297 if ((ptr = strchr_m(buf->fs_user,'@')) != NULL) {
298 *ptr = '\0';
299 }
300
301 fstrcpy(buf->fs_file,tokarr[LPRNG_FILETOK]);
302
303 if ((LPRNG_FILETOK + 1) != LPRNG_TOTALTOK) {
304 int i;
305
306 for (i = (LPRNG_FILETOK + 1); i < LPRNG_TOTALTOK; i++) {
307 /* FIXME: Using fstrcat rather than other means is a bit
308 * inefficient; this might be a problem for enormous queues with
309 * many fields. */
310 fstrcat(buf->fs_file, " ");
311 fstrcat(buf->fs_file, tokarr[i]);
312 }
313 /* Ensure null termination. */
314 fstrterminate(buf->fs_file);
315 }
316
317 return True;
318 }
319
320 /*******************************************************************
321 parse lpq on an aix system
322
323 Queue Dev Status Job Files User PP % Blks Cp Rnk
324 ------- ----- --------- --- ------------------ ---------- ---- -- ----- --- ---
325 lazer lazer READY
326 lazer lazer RUNNING 537 6297doc.A kvintus@IE 0 10 2445 1 1
327 QUEUED 538 C.ps root@IEDVB 124 1 2
328 QUEUED 539 E.ps root@IEDVB 28 1 3
329 QUEUED 540 L.ps root@IEDVB 172 1 4
330 QUEUED 541 P.ps root@IEDVB 22 1 5
331 ********************************************************************/
332
333 static BOOL parse_lpq_aix(char *line,print_queue_struct *buf,BOOL first)
334 {
335 fstring tok[11];
336 int count=0;
337 const char *cline = line;
338
339 /* handle the case of "(standard input)" as a filename */
340 string_sub(line,"standard input","STDIN",0);
341 all_string_sub(line,"(","\"",0);
342 all_string_sub(line,")","\"",0);
343
344 for (count=0; count<10 && next_token(&cline,tok[count],NULL, sizeof(tok[count])); count++) {
345 ;
346 }
347
348 /* we must get 6 tokens */
349 if (count < 10) {
350 if ((count == 7) && ((strcmp(tok[0],"QUEUED") == 0) || (strcmp(tok[0],"HELD") == 0))) {
351 /* the 2nd and 5th columns must be integer */
352 if (!isdigit((int)*tok[1]) || !isdigit((int)*tok[4])) {
353 return False;
354 }
355 buf->size = atoi(tok[4]) * 1024;
356 /* if the fname contains a space then use STDIN */
357 if (strchr_m(tok[2],' ')) {
358 fstrcpy(tok[2],"STDIN");
359 }
360
361 /* only take the last part of the filename */
362 {
363 fstring tmp;
364 char *p = strrchr_m(tok[2],'/');
365 if (p) {
366 fstrcpy(tmp,p+1);
367 fstrcpy(tok[2],tmp);
368 }
369 }
370
371 buf->job = atoi(tok[1]);
372 buf->status = strequal(tok[0],"HELD")?LPQ_PAUSED:LPQ_QUEUED;
373 buf->priority = 0;
374 buf->time = time(NULL);
375 fstrcpy(buf->fs_user,tok[3]);
376 fstrcpy(buf->fs_file,tok[2]);
377 } else {
378 DEBUG(6,("parse_lpq_aix count=%d\n", count));
379 return False;
380 }
381 } else {
382 /* the 4th and 9th columns must be integer */
383 if (!isdigit((int)*tok[3]) || !isdigit((int)*tok[8])) {
384 return False;
385 }
386
387 buf->size = atoi(tok[8]) * 1024;
388 /* if the fname contains a space then use STDIN */
389 if (strchr_m(tok[4],' ')) {
390 fstrcpy(tok[4],"STDIN");
391 }
392
393 /* only take the last part of the filename */
394 {
395 fstring tmp;
396 char *p = strrchr_m(tok[4],'/');
397 if (p) {
398 fstrcpy(tmp,p+1);
399 fstrcpy(tok[4],tmp);
400 }
401 }
402
403 buf->job = atoi(tok[3]);
404 buf->status = strequal(tok[2],"RUNNING")?LPQ_PRINTING:LPQ_QUEUED;
405 buf->priority = 0;
406 buf->time = time(NULL);
407 fstrcpy(buf->fs_user,tok[5]);
408 fstrcpy(buf->fs_file,tok[4]);
409 }
410
411 return True;
412 }
413
414 /****************************************************************************
415 parse a lpq line
416 here is an example of lpq output under hpux; note there's no space after -o !
417 $> lpstat -oljplus
418 ljplus-2153 user priority 0 Jan 19 08:14 on ljplus
419 util.c 125697 bytes
420 server.c 110712 bytes
421 ljplus-2154 user priority 0 Jan 19 08:14 from client
422 (standard input) 7551 bytes
423 ****************************************************************************/
424
425 static BOOL parse_lpq_hpux(char *line, print_queue_struct *buf, BOOL first)
426 {
427 /* must read two lines to process, therefore keep some values static */
428 static BOOL header_line_ok=False, base_prio_reset=False;
429 static fstring jobuser;
430 static int jobid;
431 static int jobprio;
432 static time_t jobtime;
433 static int jobstat=LPQ_QUEUED;
434 /* to store minimum priority to print, lpstat command should be invoked
435 with -p option first, to work */
436 static int base_prio;
437 int count;
438 char htab = '\011';
439 const char *cline = line;
440 fstring tok[12];
441
442 /* If a line begins with a horizontal TAB, it is a subline type */
443
444 if (line[0] == htab) { /* subline */
445 /* check if it contains the base priority */
446 if (!strncmp(line,"\tfence priority : ",18)) {
447 base_prio=atoi(&line[18]);
448 DEBUG(4, ("fence priority set at %d\n", base_prio));
449 }
450
451 if (!header_line_ok) {
452 return False; /* incorrect header line */
453 }
454
455 /* handle the case of "(standard input)" as a filename */
456 string_sub(line,"standard input","STDIN",0);
457 all_string_sub(line,"(","\"",0);
458 all_string_sub(line,")","\"",0);
459
460 for (count=0; count<2 && next_token(&cline,tok[count],NULL,sizeof(tok[count])); count++) {
461 ;
462 }
463 /* we must get 2 tokens */
464 if (count < 2) {
465 return False;
466 }
467
468 /* the 2nd column must be integer */
469 if (!isdigit((int)*tok[1])) {
470 return False;
471 }
472
473 /* if the fname contains a space then use STDIN */
474 if (strchr_m(tok[0],' ')) {
475 fstrcpy(tok[0],"STDIN");
476 }
477
478 buf->size = atoi(tok[1]);
479 fstrcpy(buf->fs_file,tok[0]);
480
481 /* fill things from header line */
482 buf->time = jobtime;
483 buf->job = jobid;
484 buf->status = jobstat;
485 buf->priority = jobprio;
486 fstrcpy(buf->fs_user,jobuser);
487
488 return True;
489 } else { /* header line */
490 header_line_ok=False; /* reset it */
491 if (first) {
492 if (!base_prio_reset) {
493 base_prio=0; /* reset it */
494 base_prio_reset=True;
495 }
496 } else if (base_prio) {
497 base_prio_reset=False;
498 }
499
500 /* handle the dash in the job id */
501 string_sub(line,"-"," ",0);
502
503 for (count=0; count<12 && next_token(&cline,tok[count],NULL,sizeof(tok[count])); count++) {
504 ;
505 }
506
507 /* we must get 8 tokens */
508 if (count < 8) {
509 return False;
510 }
511
512 /* first token must be printer name (cannot check ?) */
513 /* the 2nd, 5th & 7th column must be integer */
514 if (!isdigit((int)*tok[1]) || !isdigit((int)*tok[4]) || !isdigit((int)*tok[6])) {
515 return False;
516 }
517 jobid = atoi(tok[1]);
518 fstrcpy(jobuser,tok[2]);
519 jobprio = atoi(tok[4]);
520
521 /* process time */
522 jobtime=EntryTime(tok, 5, count, 8);
523 if (jobprio < base_prio) {
524 jobstat = LPQ_PAUSED;
525 DEBUG (4, ("job %d is paused: prio %d < %d; jobstat=%d\n",
526 jobid, jobprio, base_prio, jobstat));
527 } else {
528 jobstat = LPQ_QUEUED;
529 if ((count >8) && (((strequal(tok[8],"on")) ||
530 ((strequal(tok[8],"from")) &&
531 ((count > 10)&&(strequal(tok[10],"on"))))))) {
532 jobstat = LPQ_PRINTING;
533 }
534 }
535
536 header_line_ok=True; /* information is correct */
537 return False; /* need subline info to include into queuelist */
538 }
539 }
540
541 /****************************************************************************
542 parse a lpstat line
543
544 here is an example of "lpstat -o dcslw" output under sysv
545
546 dcslw-896 tridge 4712 Dec 20 10:30:30 on dcslw
547 dcslw-897 tridge 4712 Dec 20 10:30:30 being held
548
549 ****************************************************************************/
550
551 static BOOL parse_lpq_sysv(char *line,print_queue_struct *buf,BOOL first)
552 {
553 fstring tok[9];
554 int count=0;
555 char *p;
556 const char *cline = line;
557
558 /*
559 * Handle the dash in the job id, but make sure that we skip over
560 * the printer name in case we have a dash in that.
561 * Patch from Dom.Mitchell@palmerharvey.co.uk.
562 */
563
564 /*
565 * Move to the first space.
566 */
567 for (p = line ; !isspace(*p) && *p; p++) {
568 ;
569 }
570
571 /*
572 * Back up until the last '-' character or
573 * start of line.
574 */
575 for (; (p >= line) && (*p != '-'); p--) {
576 ;
577 }
578
579 if((p >= line) && (*p == '-')) {
580 *p = ' ';
581 }
582
583 for (count=0; count<9 && next_token(&cline,tok[count],NULL,sizeof(tok[count])); count++) {
584 ;
585 }
586
587 /* we must get 7 tokens */
588 if (count < 7) {
589 return False;
590 }
591
592 /* the 2nd and 4th, 6th columns must be integer */
593 if (!isdigit((int)*tok[1]) || !isdigit((int)*tok[3])) {
594 return False;
595 }
596 if (!isdigit((int)*tok[5])) {
597 return False;
598 }
599
600 /* if the user contains a ! then trim the first part of it */
601 if ((p=strchr_m(tok[2],'!'))) {
602 fstring tmp;
603 fstrcpy(tmp,p+1);
604 fstrcpy(tok[2],tmp);
605 }
606
607 buf->job = atoi(tok[1]);
608 buf->size = atoi(tok[3]);
609 if (count > 7 && strequal(tok[7],"on")) {
610 buf->status = LPQ_PRINTING;
611 } else if (count > 8 && strequal(tok[7],"being") && strequal(tok[8],"held")) {
612 buf->status = LPQ_PAUSED;
613 } else {
614 buf->status = LPQ_QUEUED;
615 }
616 buf->priority = 0;
617 buf->time = EntryTime(tok, 4, count, 7);
618 fstrcpy(buf->fs_user,tok[2]);
619 fstrcpy(buf->fs_file,tok[2]);
620 return True;
621 }
622
623 /****************************************************************************
624 parse a lpq line
625
626 here is an example of lpq output under qnx
627 Spooler: /qnx/spooler, on node 1
628 Printer: txt (ready)
629 0000: root [job #1 ] active 1146 bytes /etc/profile
630 0001: root [job #2 ] ready 2378 bytes /etc/install
631 0002: root [job #3 ] ready 1146 bytes -- standard input --
632 ****************************************************************************/
633
634 static BOOL parse_lpq_qnx(char *line,print_queue_struct *buf,BOOL first)
635 {
636 fstring tok[7];
637 int count=0;
638 const char *cline = line;
639
640 DEBUG(4,("antes [%s]\n", line));
641
642 /* handle the case of "-- standard input --" as a filename */
643 string_sub(line,"standard input","STDIN",0);
644 DEBUG(4,("despues [%s]\n", line));
645 all_string_sub(line,"-- ","\"",0);
646 all_string_sub(line," --","\"",0);
647 DEBUG(4,("despues 1 [%s]\n", line));
648
649 string_sub(line,"[job #","",0);
650 string_sub(line,"]","",0);
651 DEBUG(4,("despues 2 [%s]\n", line));
652
653 for (count=0; count<7 && next_token(&cline,tok[count],NULL,sizeof(tok[count])); count++) {
654 ;
655 }
656
657 /* we must get 7 tokens */
658 if (count < 7) {
659 return False;
660 }
661
662 /* the 3rd and 5th columns must be integer */
663 if (!isdigit((int)*tok[2]) || !isdigit((int)*tok[4])) {
664 return False;
665 }
666
667 /* only take the last part of the filename */
668 {
669 fstring tmp;
670 char *p = strrchr_m(tok[6],'/');
671 if (p) {
672 fstrcpy(tmp,p+1);
673 fstrcpy(tok[6],tmp);
674 }
675 }
676
677 buf->job = atoi(tok[2]);
678 buf->size = atoi(tok[4]);
679 buf->status = strequal(tok[3],"active")?LPQ_PRINTING:LPQ_QUEUED;
680 buf->priority = 0;
681 buf->time = time(NULL);
682 fstrcpy(buf->fs_user,tok[1]);
683 fstrcpy(buf->fs_file,tok[6]);
684 return True;
685 }
686
687 /****************************************************************************
688 parse a lpq line for the plp printing system
689 Bertrand Wallrich <Bertrand.Wallrich@loria.fr>
690
691 redone by tridge. Here is a sample queue:
692
693 Local Printer 'lp2' (fjall):
694 Printing (started at Jun 15 13:33:58, attempt 1).
695 Rank Owner Pr Opt Job Host Files Size Date
696 active tridge X - 6 fjall /etc/hosts 739 Jun 15 13:33
697 3rd tridge X - 7 fjall /etc/hosts 739 Jun 15 13:33
698
699 ****************************************************************************/
700
701 static BOOL parse_lpq_plp(char *line,print_queue_struct *buf,BOOL first)
702 {
703 fstring tok[11];
704 int count=0;
705 const char *cline = line;
706
707 /* handle the case of "(standard input)" as a filename */
708 string_sub(line,"stdin","STDIN",0);
709 all_string_sub(line,"(","\"",0);
710 all_string_sub(line,")","\"",0);
711
712 for (count=0; count<11 && next_token(&cline,tok[count],NULL,sizeof(tok[count])); count++) {
713 ;
714 }
715
716 /* we must get 11 tokens */
717 if (count < 11) {
718 return False;
719 }
720
721 /* the first must be "active" or begin with an integer */
722 if (strcmp(tok[0],"active") && !isdigit((int)tok[0][0])) {
723 return False;
724 }
725
726 /* the 5th and 8th must be integer */
727 if (!isdigit((int)*tok[4]) || !isdigit((int)*tok[7])) {
728 return False;
729 }
730
731 /* if the fname contains a space then use STDIN */
732 if (strchr_m(tok[6],' ')) {
733 fstrcpy(tok[6],"STDIN");
734 }
735
736 /* only take the last part of the filename */
737 {
738 fstring tmp;
739 char *p = strrchr_m(tok[6],'/');
740 if (p) {
741 fstrcpy(tmp,p+1);
742 fstrcpy(tok[6],tmp);
743 }
744 }
745
746 buf->job = atoi(tok[4]);
747
748 buf->size = atoi(tok[7]);
749 if (strchr_m(tok[7],'K')) {
750 buf->size *= 1024;
751 }
752 if (strchr_m(tok[7],'M')) {
753 buf->size *= 1024*1024;
754 }
755
756 buf->status = strequal(tok[0],"active")?LPQ_PRINTING:LPQ_QUEUED;
757 buf->priority = 0;
758 buf->time = time(NULL);
759 fstrcpy(buf->fs_user,tok[1]);
760 fstrcpy(buf->fs_file,tok[6]);
761 return True;
762 }
763
764 /*******************************************************************
765 parse lpq on an NT system
766
767 Windows 2000 LPD Server
768 Printer \\10.0.0.2\NP17PCL (Paused)
769
770 Owner Status Jobname Job-Id Size Pages Priority
771 ----------------------------------------------------------------------------
772 root (9.99. Printing /usr/lib/rhs/rhs-pr 3 625 0 1
773 root (9.99. Paused /usr/lib/rhs/rhs-pr 4 625 0 1
774 jmcd Waiting Re: Samba Open Sour 26 32476 1 1
775
776 ********************************************************************/
777
778 static BOOL parse_lpq_nt(char *line,print_queue_struct *buf,BOOL first)
779 {
780 #define LPRNT_OWNSIZ 11
781 #define LPRNT_STATSIZ 9
782 #define LPRNT_JOBSIZ 19
783 #define LPRNT_IDSIZ 6
784 #define LPRNT_SIZSIZ 9
785 typedef struct {
786 char owner[LPRNT_OWNSIZ];
787 char space1;
788 char status[LPRNT_STATSIZ];
789 char space2;
790 char jobname[LPRNT_JOBSIZ];
791 char space3;
792 char jobid[LPRNT_IDSIZ];
793 char space4;
794 char size[LPRNT_SIZSIZ];
795 char terminator;
796 } nt_lpq_line;
797
798 nt_lpq_line parse_line;
799 #define LPRNT_PRINTING "Printing"
800 #define LPRNT_WAITING "Waiting"
801 #define LPRNT_PAUSED "Paused"
802
803 memset(&parse_line, '\0', sizeof(parse_line));
804 strncpy((char *) &parse_line, line, sizeof(parse_line) -1);
805
806 if (strlen((char *) &parse_line) != sizeof(parse_line) - 1) {
807 return False;
808 }
809
810 /* Just want the first word in the owner field - the username */
811 if (strchr_m(parse_line.owner, ' ')) {
812 *(strchr_m(parse_line.owner, ' ')) = '\0';
813 } else {
814 parse_line.space1 = '\0';
815 }
816
817 /* Make sure we have an owner */
818 if (!strlen(parse_line.owner)) {
819 return False;
820 }
821
822 /* Make sure the status is valid */
823 parse_line.space2 = '\0';
824 trim_char(parse_line.status, '\0', ' ');
825 if (!strequal(parse_line.status, LPRNT_PRINTING) &&
826 !strequal(parse_line.status, LPRNT_PAUSED) &&
827 !strequal(parse_line.status, LPRNT_WAITING)) {
828 return False;
829 }
830
831 parse_line.space3 = '\0';
832 trim_char(parse_line.jobname, '\0', ' ');
833
834 buf->job = atoi(parse_line.jobid);
835 buf->priority = 0;
836 buf->size = atoi(parse_line.size);
837 buf->time = time(NULL);
838 fstrcpy(buf->fs_user, parse_line.owner);
839 fstrcpy(buf->fs_file, parse_line.jobname);
840 if (strequal(parse_line.status, LPRNT_PRINTING)) {
841 buf->status = LPQ_PRINTING;
842 } else if (strequal(parse_line.status, LPRNT_PAUSED)) {
843 buf->status = LPQ_PAUSED;
844 } else {
845 buf->status = LPQ_QUEUED;
846 }
847
848 return True;
849 }
850
851 /*******************************************************************
852 parse lpq on an OS2 system
853
854 JobID File Name Rank Size Status Comment
855 ----- --------------- ------ -------- ------------ ------------
856 3 Control 1 68 Queued root@psflinu
857 4 /etc/motd 2 11666 Queued root@psflinu
858
859 ********************************************************************/
860
861 static BOOL parse_lpq_os2(char *line,print_queue_struct *buf,BOOL first)
862 {
863 #define LPROS2_IDSIZ 5
864 #define LPROS2_JOBSIZ 15
865 #define LPROS2_SIZSIZ 8
866 #define LPROS2_STATSIZ 12
867 #define LPROS2_OWNSIZ 12
868 typedef struct {
869 char jobid[LPROS2_IDSIZ];
870 char space1[2];
871 char jobname[LPROS2_JOBSIZ];
872 char space2[14];
873 char size[LPROS2_SIZSIZ];
874 char space3[4];
875 char status[LPROS2_STATSIZ];
876 char space4[4];
877 char owner[LPROS2_OWNSIZ];
878 char terminator;
879 } os2_lpq_line;
880
881 os2_lpq_line parse_line;
882 #define LPROS2_PRINTING "Printing"
883 #define LPROS2_WAITING "Queued"
884 #define LPROS2_PAUSED "Paused"
885
886 memset(&parse_line, '\0', sizeof(parse_line));
887 strncpy((char *) &parse_line, line, sizeof(parse_line) -1);
888
889 if (strlen((char *) &parse_line) != sizeof(parse_line) - 1) {
890 return False;
891 }
892
893 /* Get the jobid */
894 buf->job = atoi(parse_line.jobid);
895
896 /* Get the job name */
897 parse_line.space2[0] = '\0';
898 trim_char(parse_line.jobname, '\0', ' ');
899 fstrcpy(buf->fs_file, parse_line.jobname);
900
901 buf->priority = 0;
902 buf->size = atoi(parse_line.size);
903 buf->time = time(NULL);
904
905 /* Make sure we have an owner */
906 if (!strlen(parse_line.owner)) {
907 return False;
908 }
909
910 /* Make sure we have a valid status */
911 parse_line.space4[0] = '\0';
912 trim_char(parse_line.status, '\0', ' ');
913 if (!strequal(parse_line.status, LPROS2_PRINTING) &&
914 !strequal(parse_line.status, LPROS2_PAUSED) &&
915 !strequal(parse_line.status, LPROS2_WAITING)) {
916 return False;
917 }
918
919 fstrcpy(buf->fs_user, parse_line.owner);
920 if (strequal(parse_line.status, LPROS2_PRINTING)) {
921 buf->status = LPQ_PRINTING;
922 } else if (strequal(parse_line.status, LPROS2_PAUSED)) {
923 buf->status = LPQ_PAUSED;
924 } else {
925 buf->status = LPQ_QUEUED;
926 }
927
928 return True;
929 }
930
931 static const char *stat0_strings[] = { "enabled", "online", "idle", "no entries", "free", "ready", NULL };
932 static const char *stat1_strings[] = { "offline", "disabled", "down", "off", "waiting", "no daemon", NULL };
933 static const char *stat2_strings[] = { "jam", "paper", "error", "responding", "not accepting", "not running", "turned off", NULL };
934
935 #ifdef DEVELOPER
936
937 /****************************************************************************
938 parse a vlp line
939 ****************************************************************************/
940
941 static BOOL parse_lpq_vlp(char *line,print_queue_struct *buf,BOOL first)
942 {
943 int toknum = 0;
944 fstring tok;
945 const char *cline = line;
946
947 /* First line is printer status */
948
949 if (!isdigit(line[0])) return False;
950
951 /* Parse a print job entry */
952
953 while(next_token(&cline, tok, NULL, sizeof(fstring))) {
954 switch (toknum) {
955 case 0:
956 buf->job = atoi(tok);
957 break;
958 case 1:
959 buf->size = atoi(tok);
960 break;
961 case 2:
962 buf->status = atoi(tok);
963 break;
964 case 3:
965 buf->time = atoi(tok);
966 break;
967 case 4:
968 fstrcpy(buf->fs_user, tok);
969 break;
970 case 5:
971 fstrcpy(buf->fs_file, tok);
972 break;
973 }
974 toknum++;
975 }
976
977 return True;
978 }
979
980 #endif /* DEVELOPER */
981
982 /****************************************************************************
983 parse a lpq line. Choose printing style
984 ****************************************************************************/
985
986 BOOL parse_lpq_entry(enum printing_types printing_type,char *line,
987 print_queue_struct *buf,
988 print_status_struct *status,BOOL first)
989 {
990 BOOL ret;
991
992 switch (printing_type) {
993 case PRINT_SYSV:
994 ret = parse_lpq_sysv(line,buf,first);
995 break;
996 case PRINT_AIX:
997 ret = parse_lpq_aix(line,buf,first);
998 break;
999 case PRINT_HPUX:
1000 ret = parse_lpq_hpux(line,buf,first);
1001 break;
1002 case PRINT_QNX:
1003 ret = parse_lpq_qnx(line,buf,first);
1004 break;
1005 case PRINT_LPRNG:
1006 ret = parse_lpq_lprng(line,buf,first);
1007 break;
1008 case PRINT_PLP:
1009 ret = parse_lpq_plp(line,buf,first);
1010 break;
1011 case PRINT_LPRNT:
1012 ret = parse_lpq_nt(line,buf,first);
1013 break;
1014 case PRINT_LPROS2:
1015 ret = parse_lpq_os2(line,buf,first);
1016 break;
1017 #ifdef DEVELOPER
1018 case PRINT_VLP:
1019 case PRINT_TEST:
1020 ret = parse_lpq_vlp(line,buf,first);
1021 break;
1022 #endif /* DEVELOPER */
1023 default:
1024 ret = parse_lpq_bsd(line,buf,first);
1025 break;
1026 }
1027
1028 /* We don't want the newline in the status message. */
1029 {
1030 char *p = strchr_m(line,'\n');
1031 if (p) {
1032 *p = 0;
1033 }
1034 }
1035
1036 /* in the LPRNG case, we skip lines starting by a space.*/
1037 if (!ret && (printing_type==PRINT_LPRNG) ) {
1038 if (line[0]==' ') {
1039 return ret;
1040 }
1041 }
1042
1043 if (status && !ret) {
1044 /* a few simple checks to see if the line might be a
1045 printer status line:
1046 handle them so that most severe condition is shown */
1047 int i;
1048 strlower_m(line);
1049
1050 switch (status->status) {
1051 case LPSTAT_OK:
1052 for (i=0; stat0_strings[i]; i++) {
1053 if (strstr_m(line,stat0_strings[i])) {
1054 fstrcpy(status->message,line);
1055 status->status=LPSTAT_OK;
1056 return ret;
1057 }
1058 }
1059 /* fallthrough */
1060 case LPSTAT_STOPPED:
1061 for (i=0; stat1_strings[i]; i++) {
1062 if (strstr_m(line,stat1_strings[i])) {
1063 fstrcpy(status->message,line);
1064 status->status=LPSTAT_STOPPED;
1065 return ret;
1066 }
1067 }
1068 /* fallthrough */
1069 case LPSTAT_ERROR:
1070 for (i=0; stat2_strings[i]; i++) {
1071 if (strstr_m(line,stat2_strings[i])) {
1072 fstrcpy(status->message,line);
1073 status->status=LPSTAT_ERROR;
1074 return ret;
1075 }
1076 }
1077 break;
1078 }
1079 }
1080
1081 return ret;
1082 }
Samba GIT mirror