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