Context Navigation

source: branches/samba-3.5.x/source3/printing/lpq_parse.c

Visit:

Last change on this file was 480, checked in by Silvan Scherrer, 15 years ago
Samba Server 3.5: trunk update to 3.5.4
File size: 30.6 KB

Line
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_hour60+t->tm_min < hour60+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 = 10241024;
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	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: