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