source: branches/samba-3.0/source/printing/printing.c

Last change on this file was 158, checked in by Paul Smedley, 17 years ago

Update source to 3.0.32
File size: 78.4 KB
RevLine 
[134]1/*
2 Unix SMB/Netbios implementation.
3 Version 3.0
4 printing backend routines
5 Copyright (C) Andrew Tridgell 1992-2000
6 Copyright (C) Jeremy Allison 2002
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21*/
22
23#include "includes.h"
24#include "printing.h"
25
26extern SIG_ATOMIC_T got_sig_term;
27extern SIG_ATOMIC_T reload_after_sighup;
28extern struct current_user current_user;
29extern userdom_struct current_user_info;
30
31/* Current printer interface */
32static BOOL remove_from_jobs_changed(const char* sharename, uint32 jobid);
33
34/*
35 the printing backend revolves around a tdb database that stores the
36 SMB view of the print queue
37
38 The key for this database is a jobid - a internally generated number that
39 uniquely identifies a print job
40
41 reading the print queue involves two steps:
42 - possibly running lpq and updating the internal database from that
43 - reading entries from the database
44
45 jobids are assigned when a job starts spooling.
46*/
47
48static TDB_CONTEXT *rap_tdb;
49static uint16 next_rap_jobid;
50struct rap_jobid_key {
51 fstring sharename;
52 uint32 jobid;
53};
54
55/***************************************************************************
56 Nightmare. LANMAN jobid's are 16 bit numbers..... We must map them to 32
57 bit RPC jobids.... JRA.
58***************************************************************************/
59
60uint16 pjobid_to_rap(const char* sharename, uint32 jobid)
61{
62 uint16 rap_jobid;
63 TDB_DATA data, key;
64 struct rap_jobid_key jinfo;
65 uint8 buf[2];
66
67 DEBUG(10,("pjobid_to_rap: called.\n"));
68
69 if (!rap_tdb) {
70 /* Create the in-memory tdb. */
71 rap_tdb = tdb_open_log(NULL, 0, TDB_INTERNAL, (O_RDWR|O_CREAT), 0644);
72 if (!rap_tdb)
73 return 0;
74 }
75
76 ZERO_STRUCT( jinfo );
77 fstrcpy( jinfo.sharename, sharename );
78 jinfo.jobid = jobid;
79 key.dptr = (char*)&jinfo;
80 key.dsize = sizeof(jinfo);
81
82 data = tdb_fetch(rap_tdb, key);
83 if (data.dptr && data.dsize == sizeof(uint16)) {
84 rap_jobid = SVAL(data.dptr, 0);
85 SAFE_FREE(data.dptr);
86 DEBUG(10,("pjobid_to_rap: jobid %u maps to RAP jobid %u\n",
87 (unsigned int)jobid, (unsigned int)rap_jobid));
88 return rap_jobid;
89 }
90 SAFE_FREE(data.dptr);
91 /* Not found - create and store mapping. */
92 rap_jobid = ++next_rap_jobid;
93 if (rap_jobid == 0)
94 rap_jobid = ++next_rap_jobid;
95 SSVAL(buf,0,rap_jobid);
96 data.dptr = (char*)buf;
97 data.dsize = sizeof(rap_jobid);
98 tdb_store(rap_tdb, key, data, TDB_REPLACE);
99 tdb_store(rap_tdb, data, key, TDB_REPLACE);
100
101 DEBUG(10,("pjobid_to_rap: created jobid %u maps to RAP jobid %u\n",
102 (unsigned int)jobid, (unsigned int)rap_jobid));
103 return rap_jobid;
104}
105
106BOOL rap_to_pjobid(uint16 rap_jobid, fstring sharename, uint32 *pjobid)
107{
108 TDB_DATA data, key;
109 uint8 buf[2];
110
111 DEBUG(10,("rap_to_pjobid called.\n"));
112
113 if (!rap_tdb)
114 return False;
115
116 SSVAL(buf,0,rap_jobid);
117 key.dptr = (char*)buf;
118 key.dsize = sizeof(rap_jobid);
119 data = tdb_fetch(rap_tdb, key);
120 if ( data.dptr && data.dsize == sizeof(struct rap_jobid_key) )
121 {
122 struct rap_jobid_key *jinfo = (struct rap_jobid_key*)data.dptr;
123 fstrcpy( sharename, jinfo->sharename );
124 *pjobid = jinfo->jobid;
125 DEBUG(10,("rap_to_pjobid: jobid %u maps to RAP jobid %u\n",
126 (unsigned int)*pjobid, (unsigned int)rap_jobid));
127 SAFE_FREE(data.dptr);
128 return True;
129 }
130
131 DEBUG(10,("rap_to_pjobid: Failed to lookup RAP jobid %u\n",
132 (unsigned int)rap_jobid));
133 SAFE_FREE(data.dptr);
134 return False;
135}
136
137static void rap_jobid_delete(const char* sharename, uint32 jobid)
138{
139 TDB_DATA key, data;
140 uint16 rap_jobid;
141 struct rap_jobid_key jinfo;
142 uint8 buf[2];
143
144 DEBUG(10,("rap_jobid_delete: called.\n"));
145
146 if (!rap_tdb)
147 return;
148
149 ZERO_STRUCT( jinfo );
150 fstrcpy( jinfo.sharename, sharename );
151 jinfo.jobid = jobid;
152 key.dptr = (char*)&jinfo;
153 key.dsize = sizeof(jinfo);
154
155 data = tdb_fetch(rap_tdb, key);
156 if (!data.dptr || (data.dsize != sizeof(uint16))) {
157 DEBUG(10,("rap_jobid_delete: cannot find jobid %u\n",
158 (unsigned int)jobid ));
159 SAFE_FREE(data.dptr);
160 return;
161 }
162
163 DEBUG(10,("rap_jobid_delete: deleting jobid %u\n",
164 (unsigned int)jobid ));
165
166 rap_jobid = SVAL(data.dptr, 0);
167 SAFE_FREE(data.dptr);
168 SSVAL(buf,0,rap_jobid);
169 data.dptr = (char*)buf;
170 data.dsize = sizeof(rap_jobid);
171 tdb_delete(rap_tdb, key);
172 tdb_delete(rap_tdb, data);
173}
174
175static int get_queue_status(const char* sharename, print_status_struct *);
176
177/****************************************************************************
178 Initialise the printing backend. Called once at startup before the fork().
179****************************************************************************/
180
181BOOL print_backend_init(void)
182{
183 const char *sversion = "INFO/version";
184 pstring printing_path;
185 int services = lp_numservices();
186 int snum;
187
188 unlink(lock_path("printing.tdb"));
189 pstrcpy(printing_path,lock_path("printing"));
190 mkdir(printing_path,0755);
191
192 /* handle a Samba upgrade */
193
194 for (snum = 0; snum < services; snum++) {
195 struct tdb_print_db *pdb;
196 if (!lp_print_ok(snum))
197 continue;
198
199 pdb = get_print_db_byname(lp_const_servicename(snum));
200 if (!pdb)
201 continue;
202 if (tdb_lock_bystring(pdb->tdb, sversion) == -1) {
203 DEBUG(0,("print_backend_init: Failed to open printer %s database\n", lp_const_servicename(snum) ));
204 release_print_db(pdb);
205 return False;
206 }
207 if (tdb_fetch_int32(pdb->tdb, sversion) != PRINT_DATABASE_VERSION) {
208 tdb_traverse(pdb->tdb, tdb_traverse_delete_fn, NULL);
209 tdb_store_int32(pdb->tdb, sversion, PRINT_DATABASE_VERSION);
210 }
211 tdb_unlock_bystring(pdb->tdb, sversion);
212 release_print_db(pdb);
213 }
214
215 close_all_print_db(); /* Don't leave any open. */
216
217 /* do NT print initialization... */
218 return nt_printing_init();
219}
220
221/****************************************************************************
222 Shut down printing backend. Called once at shutdown to close the tdb.
223****************************************************************************/
224
225void printing_end(void)
226{
227 close_all_print_db(); /* Don't leave any open. */
228}
229
230/****************************************************************************
231 Retrieve the set of printing functions for a given service. This allows
232 us to set the printer function table based on the value of the 'printing'
233 service parameter.
234
235 Use the generic interface as the default and only use cups interface only
236 when asked for (and only when supported)
237****************************************************************************/
238
239static struct printif *get_printer_fns_from_type( enum printing_types type )
240{
241 struct printif *printer_fns = &generic_printif;
242
243#ifdef HAVE_CUPS
244 if ( type == PRINT_CUPS ) {
245 printer_fns = &cups_printif;
246 }
247#endif /* HAVE_CUPS */
248
249#ifdef HAVE_IPRINT
250 if ( type == PRINT_IPRINT ) {
251 printer_fns = &iprint_printif;
252 }
253#endif /* HAVE_IPRINT */
254
255 printer_fns->type = type;
256
257 return printer_fns;
258}
259
260static struct printif *get_printer_fns( int snum )
261{
262 return get_printer_fns_from_type( (enum printing_types)lp_printing(snum) );
263}
264
265
266/****************************************************************************
267 Useful function to generate a tdb key.
268****************************************************************************/
269
270static TDB_DATA print_key(uint32 jobid)
271{
272 static uint32 j;
273 TDB_DATA ret;
274
275 SIVAL(&j, 0, jobid);
276 ret.dptr = (char *)&j;
277 ret.dsize = sizeof(j);
278 return ret;
279}
280
281/***********************************************************************
282 unpack a pjob from a tdb buffer
283***********************************************************************/
284
285int unpack_pjob( char* buf, int buflen, struct printjob *pjob )
286{
287 int len = 0;
288 int used;
289 uint32 pjpid, pjsysjob, pjfd, pjstarttime, pjstatus;
290 uint32 pjsize, pjpage_count, pjspooled, pjsmbjob;
291
292 if ( !buf || !pjob )
293 return -1;
294
295 len += tdb_unpack(buf+len, buflen-len, "dddddddddffff",
296 &pjpid,
297 &pjsysjob,
298 &pjfd,
299 &pjstarttime,
300 &pjstatus,
301 &pjsize,
302 &pjpage_count,
303 &pjspooled,
304 &pjsmbjob,
305 pjob->filename,
306 pjob->jobname,
307 pjob->user,
308 pjob->queuename);
309
310 if ( len == -1 )
311 return -1;
312
313 if ( (used = unpack_devicemode(&pjob->nt_devmode, buf+len, buflen-len)) == -1 )
314 return -1;
315
316 len += used;
317
318 pjob->pid = pjpid;
319 pjob->sysjob = pjsysjob;
320 pjob->fd = pjfd;
321 pjob->starttime = pjstarttime;
322 pjob->status = pjstatus;
323 pjob->size = pjsize;
324 pjob->page_count = pjpage_count;
325 pjob->spooled = pjspooled;
326 pjob->smbjob = pjsmbjob;
327
328 return len;
329
330}
331
332/****************************************************************************
333 Useful function to find a print job in the database.
334****************************************************************************/
335
336static struct printjob *print_job_find(const char *sharename, uint32 jobid)
337{
338 static struct printjob pjob;
339 TDB_DATA ret;
340 struct tdb_print_db *pdb = get_print_db_byname(sharename);
341
342 DEBUG(10,("print_job_find: looking up job %u for share %s\n",
343 (unsigned int)jobid, sharename ));
344
345 if (!pdb) {
346 return NULL;
347 }
348
349 ret = tdb_fetch(pdb->tdb, print_key(jobid));
350 release_print_db(pdb);
351
352 if (!ret.dptr) {
353 DEBUG(10,("print_job_find: failed to find jobid %u.\n", (unsigned int)jobid ));
354 return NULL;
355 }
356
357 if ( pjob.nt_devmode ) {
358 free_nt_devicemode( &pjob.nt_devmode );
359 }
360
361 ZERO_STRUCT( pjob );
362
363 if ( unpack_pjob( ret.dptr, ret.dsize, &pjob ) == -1 ) {
364 DEBUG(10,("print_job_find: failed to unpack jobid %u.\n", (unsigned int)jobid ));
365 SAFE_FREE(ret.dptr);
366 return NULL;
367 }
368
369 SAFE_FREE(ret.dptr);
370
371 DEBUG(10,("print_job_find: returning system job %d for jobid %u.\n",
372 (int)pjob.sysjob, (unsigned int)jobid ));
373
374 return &pjob;
375}
376
377/* Convert a unix jobid to a smb jobid */
378
379static uint32 sysjob_to_jobid_value;
380
381static int unixjob_traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA key,
382 TDB_DATA data, void *state)
383{
384 struct printjob *pjob;
385 int *sysjob = (int *)state;
386
387 if (!data.dptr || data.dsize == 0)
388 return 0;
389
390 pjob = (struct printjob *)data.dptr;
391 if (key.dsize != sizeof(uint32))
392 return 0;
393
394 if (*sysjob == pjob->sysjob) {
395 uint32 jobid = IVAL(key.dptr,0);
396
397 sysjob_to_jobid_value = jobid;
398 return 1;
399 }
400
401 return 0;
402}
403
404/****************************************************************************
405 This is a *horribly expensive call as we have to iterate through all the
406 current printer tdb's. Don't do this often ! JRA.
407****************************************************************************/
408
409uint32 sysjob_to_jobid(int unix_jobid)
410{
411 int services = lp_numservices();
412 int snum;
413
414 sysjob_to_jobid_value = (uint32)-1;
415
416 for (snum = 0; snum < services; snum++) {
417 struct tdb_print_db *pdb;
418 if (!lp_print_ok(snum))
419 continue;
420 pdb = get_print_db_byname(lp_const_servicename(snum));
421 if (!pdb) {
422 continue;
423 }
424 tdb_traverse(pdb->tdb, unixjob_traverse_fn, &unix_jobid);
425 release_print_db(pdb);
426 if (sysjob_to_jobid_value != (uint32)-1)
427 return sysjob_to_jobid_value;
428 }
429 return (uint32)-1;
430}
431
432/****************************************************************************
433 Send notifications based on what has changed after a pjob_store.
434****************************************************************************/
435
436static struct {
437 uint32 lpq_status;
438 uint32 spoolss_status;
439} lpq_to_spoolss_status_map[] = {
440 { LPQ_QUEUED, JOB_STATUS_QUEUED },
441 { LPQ_PAUSED, JOB_STATUS_PAUSED },
442 { LPQ_SPOOLING, JOB_STATUS_SPOOLING },
443 { LPQ_PRINTING, JOB_STATUS_PRINTING },
444 { LPQ_DELETING, JOB_STATUS_DELETING },
445 { LPQ_OFFLINE, JOB_STATUS_OFFLINE },
446 { LPQ_PAPEROUT, JOB_STATUS_PAPEROUT },
447 { LPQ_PRINTED, JOB_STATUS_PRINTED },
448 { LPQ_DELETED, JOB_STATUS_DELETED },
449 { LPQ_BLOCKED, JOB_STATUS_BLOCKED },
450 { LPQ_USER_INTERVENTION, JOB_STATUS_USER_INTERVENTION },
451 { -1, 0 }
452};
453
454/* Convert a lpq status value stored in printing.tdb into the
455 appropriate win32 API constant. */
456
457static uint32 map_to_spoolss_status(uint32 lpq_status)
458{
459 int i = 0;
460
461 while (lpq_to_spoolss_status_map[i].lpq_status != -1) {
462 if (lpq_to_spoolss_status_map[i].lpq_status == lpq_status)
463 return lpq_to_spoolss_status_map[i].spoolss_status;
464 i++;
465 }
466
467 return 0;
468}
469
470static void pjob_store_notify(const char* sharename, uint32 jobid, struct printjob *old_data,
471 struct printjob *new_data)
472{
473 BOOL new_job = False;
474
475 if (!old_data)
476 new_job = True;
477
478 /* Job attributes that can't be changed. We only send
479 notification for these on a new job. */
480
481 /* ACHTUNG! Due to a bug in Samba's spoolss parsing of the
482 NOTIFY_INFO_DATA buffer, we *have* to send the job submission
483 time first or else we'll end up with potential alignment
484 errors. I don't think the systemtime should be spooled as
485 a string, but this gets us around that error.
486 --jerry (i'll feel dirty for this) */
487
488 if (new_job) {
489 notify_job_submitted(sharename, jobid, new_data->starttime);
490 notify_job_username(sharename, jobid, new_data->user);
491 }
492
493 if (new_job || !strequal(old_data->jobname, new_data->jobname))
494 notify_job_name(sharename, jobid, new_data->jobname);
495
496 /* Job attributes of a new job or attributes that can be
497 modified. */
498
499 if (new_job || !strequal(old_data->jobname, new_data->jobname))
500 notify_job_name(sharename, jobid, new_data->jobname);
501
502 if (new_job || old_data->status != new_data->status)
503 notify_job_status(sharename, jobid, map_to_spoolss_status(new_data->status));
504
505 if (new_job || old_data->size != new_data->size)
506 notify_job_total_bytes(sharename, jobid, new_data->size);
507
508 if (new_job || old_data->page_count != new_data->page_count)
509 notify_job_total_pages(sharename, jobid, new_data->page_count);
510}
511
512/****************************************************************************
513 Store a job structure back to the database.
514****************************************************************************/
515
516static BOOL pjob_store(const char* sharename, uint32 jobid, struct printjob *pjob)
517{
518 TDB_DATA old_data, new_data;
519 BOOL ret = False;
520 struct tdb_print_db *pdb = get_print_db_byname(sharename);
521 char *buf = NULL;
522 int len, newlen, buflen;
523
524
525 if (!pdb)
526 return False;
527
528 /* Get old data */
529
530 old_data = tdb_fetch(pdb->tdb, print_key(jobid));
531
532 /* Doh! Now we have to pack/unpack data since the NT_DEVICEMODE was added */
533
534 newlen = 0;
535
536 do {
537 len = 0;
538 buflen = newlen;
539 len += tdb_pack(buf+len, buflen-len, "dddddddddffff",
540 (uint32)pjob->pid,
541 (uint32)pjob->sysjob,
542 (uint32)pjob->fd,
543 (uint32)pjob->starttime,
544 (uint32)pjob->status,
545 (uint32)pjob->size,
546 (uint32)pjob->page_count,
547 (uint32)pjob->spooled,
548 (uint32)pjob->smbjob,
549 pjob->filename,
550 pjob->jobname,
551 pjob->user,
552 pjob->queuename);
553
554 len += pack_devicemode(pjob->nt_devmode, buf+len, buflen-len);
555
556 if (buflen != len) {
557 buf = (char *)SMB_REALLOC(buf, len);
558 if (!buf) {
559 DEBUG(0,("pjob_store: failed to enlarge buffer!\n"));
560 goto done;
561 }
562 newlen = len;
563 }
564 } while ( buflen != len );
565
566
567 /* Store new data */
568
569 new_data.dptr = buf;
570 new_data.dsize = len;
571 ret = (tdb_store(pdb->tdb, print_key(jobid), new_data, TDB_REPLACE) == 0);
572
573 release_print_db(pdb);
574
575 /* Send notify updates for what has changed */
576
577 if ( ret ) {
578 struct printjob old_pjob;
579
580 if ( old_data.dsize )
581 {
582 if ( unpack_pjob( old_data.dptr, old_data.dsize, &old_pjob ) != -1 )
583 {
584 pjob_store_notify( sharename, jobid, &old_pjob , pjob );
585 free_nt_devicemode( &old_pjob.nt_devmode );
586 }
587 }
588 else {
589 /* new job */
590 pjob_store_notify( sharename, jobid, NULL, pjob );
591 }
592 }
593
594done:
595 SAFE_FREE( old_data.dptr );
596 SAFE_FREE( buf );
597
598 return ret;
599}
600
601/****************************************************************************
602 Remove a job structure from the database.
603****************************************************************************/
604
605void pjob_delete(const char* sharename, uint32 jobid)
606{
607 struct printjob *pjob;
608 uint32 job_status = 0;
609 struct tdb_print_db *pdb;
610
611 pdb = get_print_db_byname( sharename );
612
613 if (!pdb)
614 return;
615
616 pjob = print_job_find( sharename, jobid );
617
618 if (!pjob) {
619 DEBUG(5, ("pjob_delete: we were asked to delete nonexistent job %u\n",
620 (unsigned int)jobid));
621 release_print_db(pdb);
622 return;
623 }
624
625 /* We must cycle through JOB_STATUS_DELETING and
626 JOB_STATUS_DELETED for the port monitor to delete the job
627 properly. */
628
629 job_status = JOB_STATUS_DELETING|JOB_STATUS_DELETED;
630 notify_job_status(sharename, jobid, job_status);
631
632 /* Remove from printing.tdb */
633
634 tdb_delete(pdb->tdb, print_key(jobid));
635 remove_from_jobs_changed(sharename, jobid);
636 release_print_db( pdb );
637 rap_jobid_delete(sharename, jobid);
638}
639
640/****************************************************************************
641 Parse a file name from the system spooler to generate a jobid.
642****************************************************************************/
643
644static uint32 print_parse_jobid(char *fname)
645{
646 int jobid;
647
648 if (strncmp(fname,PRINT_SPOOL_PREFIX,strlen(PRINT_SPOOL_PREFIX)) != 0)
649 return (uint32)-1;
650 fname += strlen(PRINT_SPOOL_PREFIX);
651
652 jobid = atoi(fname);
653 if (jobid <= 0)
654 return (uint32)-1;
655
656 return (uint32)jobid;
657}
658
659/****************************************************************************
660 List a unix job in the print database.
661****************************************************************************/
662
663static void print_unix_job(const char *sharename, print_queue_struct *q, uint32 jobid)
664{
665 struct printjob pj, *old_pj;
666
667 if (jobid == (uint32)-1)
668 jobid = q->job + UNIX_JOB_START;
669
670 /* Preserve the timestamp on an existing unix print job */
671
672 old_pj = print_job_find(sharename, jobid);
673
674 ZERO_STRUCT(pj);
675
676 pj.pid = (pid_t)-1;
677 pj.sysjob = q->job;
678 pj.fd = -1;
679 pj.starttime = old_pj ? old_pj->starttime : q->time;
680 pj.status = q->status;
681 pj.size = q->size;
682 pj.spooled = True;
683 fstrcpy(pj.filename, old_pj ? old_pj->filename : "");
684 if (jobid < UNIX_JOB_START) {
685 pj.smbjob = True;
686 fstrcpy(pj.jobname, old_pj ? old_pj->jobname : "Remote Downlevel Document");
687 } else {
688 pj.smbjob = False;
689 fstrcpy(pj.jobname, old_pj ? old_pj->jobname : q->fs_file);
690 }
691 fstrcpy(pj.user, old_pj ? old_pj->user : q->fs_user);
692 fstrcpy(pj.queuename, old_pj ? old_pj->queuename : sharename );
693
694 pjob_store(sharename, jobid, &pj);
695}
696
697
698struct traverse_struct {
699 print_queue_struct *queue;
700 int qcount, snum, maxcount, total_jobs;
701 const char *sharename;
702 time_t lpq_time;
703 const char *lprm_command;
704 struct printif *print_if;
705};
706
707/****************************************************************************
708 Utility fn to delete any jobs that are no longer active.
709****************************************************************************/
710
711static int traverse_fn_delete(TDB_CONTEXT *t, TDB_DATA key, TDB_DATA data, void *state)
712{
713 struct traverse_struct *ts = (struct traverse_struct *)state;
714 struct printjob pjob;
715 uint32 jobid;
716 int i = 0;
717
718 if ( key.dsize != sizeof(jobid) )
719 return 0;
720
721 jobid = IVAL(key.dptr, 0);
722 if ( unpack_pjob( data.dptr, data.dsize, &pjob ) == -1 )
723 return 0;
724 free_nt_devicemode( &pjob.nt_devmode );
725
726
727 if (!pjob.smbjob) {
728 /* remove a unix job if it isn't in the system queue any more */
729
730 for (i=0;i<ts->qcount;i++) {
731 uint32 u_jobid = (ts->queue[i].job + UNIX_JOB_START);
732 if (jobid == u_jobid)
733 break;
734 }
735 if (i == ts->qcount) {
736 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !smbjob\n",
737 (unsigned int)jobid ));
738 pjob_delete(ts->sharename, jobid);
739 return 0;
740 }
741
742 /* need to continue the the bottom of the function to
743 save the correct attributes */
744 }
745
746 /* maybe it hasn't been spooled yet */
747 if (!pjob.spooled) {
748 /* if a job is not spooled and the process doesn't
749 exist then kill it. This cleans up after smbd
750 deaths */
751 if (!process_exists_by_pid(pjob.pid)) {
752 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !process_exists (%u)\n",
753 (unsigned int)jobid, (unsigned int)pjob.pid ));
754 pjob_delete(ts->sharename, jobid);
755 } else
756 ts->total_jobs++;
757 return 0;
758 }
759
760 /* this check only makes sense for jobs submitted from Windows clients */
761
762 if ( pjob.smbjob ) {
763 for (i=0;i<ts->qcount;i++) {
764 uint32 curr_jobid;
765
766 if ( pjob.status == LPQ_DELETED )
767 continue;
768
769 curr_jobid = print_parse_jobid(ts->queue[i].fs_file);
770
771 if (jobid == curr_jobid) {
772
773 /* try to clean up any jobs that need to be deleted */
774
775 if ( pjob.status == LPQ_DELETING ) {
776 int result;
777
778 result = (*(ts->print_if->job_delete))(
779 ts->sharename, ts->lprm_command, &pjob );
780
781 if ( result != 0 ) {
782 /* if we can't delete, then reset the job status */
783 pjob.status = LPQ_QUEUED;
784 pjob_store(ts->sharename, jobid, &pjob);
785 }
786 else {
787 /* if we deleted the job, the remove the tdb record */
788 pjob_delete(ts->sharename, jobid);
789 pjob.status = LPQ_DELETED;
790 }
791
792 }
793
794 break;
795 }
796 }
797 }
798
799 /* The job isn't in the system queue - we have to assume it has
800 completed, so delete the database entry. */
801
802 if (i == ts->qcount) {
803
804 /* A race can occur between the time a job is spooled and
805 when it appears in the lpq output. This happens when
806 the job is added to printing.tdb when another smbd
807 running print_queue_update() has completed a lpq and
808 is currently traversing the printing tdb and deleting jobs.
809 Don't delete the job if it was submitted after the lpq_time. */
810
811 if (pjob.starttime < ts->lpq_time) {
812 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to pjob.starttime (%u) < ts->lpq_time (%u)\n",
813 (unsigned int)jobid,
814 (unsigned int)pjob.starttime,
815 (unsigned int)ts->lpq_time ));
816 pjob_delete(ts->sharename, jobid);
817 } else
818 ts->total_jobs++;
819 return 0;
820 }
821
822 /* Save the pjob attributes we will store.
823 FIXME!!! This is the only place where queue->job
824 represents the SMB jobid --jerry */
825
826 ts->queue[i].job = jobid;
827 ts->queue[i].size = pjob.size;
828 ts->queue[i].page_count = pjob.page_count;
829 ts->queue[i].status = pjob.status;
830 ts->queue[i].priority = 1;
831 ts->queue[i].time = pjob.starttime;
832 fstrcpy(ts->queue[i].fs_user, pjob.user);
833 fstrcpy(ts->queue[i].fs_file, pjob.jobname);
834
835 ts->total_jobs++;
836
837 return 0;
838}
839
840/****************************************************************************
841 Check if the print queue has been updated recently enough.
842****************************************************************************/
843
844static void print_cache_flush(const char *sharename)
845{
846 fstring key;
847 struct tdb_print_db *pdb = get_print_db_byname(sharename);
848
849 if (!pdb)
850 return;
851 slprintf(key, sizeof(key)-1, "CACHE/%s", sharename);
852 tdb_store_int32(pdb->tdb, key, -1);
853 release_print_db(pdb);
854}
855
856/****************************************************************************
857 Check if someone already thinks they are doing the update.
858****************************************************************************/
859
860static pid_t get_updating_pid(const char *sharename)
861{
862 fstring keystr;
863 TDB_DATA data, key;
864 pid_t updating_pid;
865 struct tdb_print_db *pdb = get_print_db_byname(sharename);
866
867 if (!pdb)
868 return (pid_t)-1;
869 slprintf(keystr, sizeof(keystr)-1, "UPDATING/%s", sharename);
870 key.dptr = keystr;
871 key.dsize = strlen(keystr);
872
873 data = tdb_fetch(pdb->tdb, key);
874 release_print_db(pdb);
875 if (!data.dptr || data.dsize != sizeof(pid_t)) {
876 SAFE_FREE(data.dptr);
877 return (pid_t)-1;
878 }
879
880 updating_pid = IVAL(data.dptr, 0);
881 SAFE_FREE(data.dptr);
882
883 if (process_exists_by_pid(updating_pid))
884 return updating_pid;
885
886 return (pid_t)-1;
887}
888
889/****************************************************************************
890 Set the fact that we're doing the update, or have finished doing the update
891 in the tdb.
892****************************************************************************/
893
894static void set_updating_pid(const fstring sharename, BOOL updating)
895{
896 fstring keystr;
897 TDB_DATA key;
898 TDB_DATA data;
899 pid_t updating_pid = sys_getpid();
900 uint8 buffer[4];
901
902 struct tdb_print_db *pdb = get_print_db_byname(sharename);
903
904 if (!pdb)
905 return;
906
907 slprintf(keystr, sizeof(keystr)-1, "UPDATING/%s", sharename);
908 key.dptr = keystr;
909 key.dsize = strlen(keystr);
910
911 DEBUG(5, ("set_updating_pid: %s updating lpq cache for print share %s\n",
912 updating ? "" : "not ",
913 sharename ));
914
915 if ( !updating ) {
916 tdb_delete(pdb->tdb, key);
917 release_print_db(pdb);
918 return;
919 }
920
921 SIVAL( buffer, 0, updating_pid);
922 data.dptr = (char *)buffer;
923 data.dsize = 4; /* we always assume this is a 4 byte value */
924
925 tdb_store(pdb->tdb, key, data, TDB_REPLACE);
926 release_print_db(pdb);
927}
928
929/****************************************************************************
930 Sort print jobs by submittal time.
931****************************************************************************/
932
933static int printjob_comp(print_queue_struct *j1, print_queue_struct *j2)
934{
935 /* Silly cases */
936
937 if (!j1 && !j2)
938 return 0;
939 if (!j1)
940 return -1;
941 if (!j2)
942 return 1;
943
944 /* Sort on job start time */
945
946 if (j1->time == j2->time)
947 return 0;
948 return (j1->time > j2->time) ? 1 : -1;
949}
950
951/****************************************************************************
952 Store the sorted queue representation for later portmon retrieval.
953 Skip deleted jobs
954****************************************************************************/
955
956static void store_queue_struct(struct tdb_print_db *pdb, struct traverse_struct *pts)
957{
958 TDB_DATA data;
959 int max_reported_jobs = lp_max_reported_jobs(pts->snum);
960 print_queue_struct *queue = pts->queue;
961 size_t len;
962 size_t i;
963 uint qcount;
964
965 if (max_reported_jobs && (max_reported_jobs < pts->qcount))
966 pts->qcount = max_reported_jobs;
967 qcount = 0;
968
969 /* Work out the size. */
970 data.dsize = 0;
971 data.dsize += tdb_pack(NULL, 0, "d", qcount);
972
973 for (i = 0; i < pts->qcount; i++) {
974 if ( queue[i].status == LPQ_DELETED )
975 continue;
976
977 qcount++;
978 data.dsize += tdb_pack(NULL, 0, "ddddddff",
979 (uint32)queue[i].job,
980 (uint32)queue[i].size,
981 (uint32)queue[i].page_count,
982 (uint32)queue[i].status,
983 (uint32)queue[i].priority,
984 (uint32)queue[i].time,
985 queue[i].fs_user,
986 queue[i].fs_file);
987 }
988
989 if ((data.dptr = (char *)SMB_MALLOC(data.dsize)) == NULL)
990 return;
991
992 len = 0;
993 len += tdb_pack(data.dptr + len, data.dsize - len, "d", qcount);
994 for (i = 0; i < pts->qcount; i++) {
995 if ( queue[i].status == LPQ_DELETED )
996 continue;
997
998 len += tdb_pack(data.dptr + len, data.dsize - len, "ddddddff",
999 (uint32)queue[i].job,
1000 (uint32)queue[i].size,
1001 (uint32)queue[i].page_count,
1002 (uint32)queue[i].status,
1003 (uint32)queue[i].priority,
1004 (uint32)queue[i].time,
1005 queue[i].fs_user,
1006 queue[i].fs_file);
1007 }
1008
1009 tdb_store(pdb->tdb, string_tdb_data("INFO/linear_queue_array"), data,
1010 TDB_REPLACE);
1011 SAFE_FREE(data.dptr);
1012 return;
1013}
1014
1015static TDB_DATA get_jobs_changed_data(struct tdb_print_db *pdb)
1016{
1017 TDB_DATA data;
1018
1019 ZERO_STRUCT(data);
1020
1021 data = tdb_fetch(pdb->tdb, string_tdb_data("INFO/jobs_changed"));
1022 if (data.dptr == NULL || data.dsize == 0 || (data.dsize % 4 != 0)) {
1023 SAFE_FREE(data.dptr);
1024 ZERO_STRUCT(data);
1025 }
1026
1027 return data;
1028}
1029
1030static void check_job_changed(const char *sharename, TDB_DATA data, uint32 jobid)
1031{
1032 unsigned int i;
1033 unsigned int job_count = data.dsize / 4;
1034
1035 for (i = 0; i < job_count; i++) {
1036 uint32 ch_jobid;
1037
1038 ch_jobid = IVAL(data.dptr, i*4);
1039 if (ch_jobid == jobid)
1040 remove_from_jobs_changed(sharename, jobid);
1041 }
1042}
1043
1044/****************************************************************************
1045 Check if the print queue has been updated recently enough.
1046****************************************************************************/
1047
1048static BOOL print_cache_expired(const char *sharename, BOOL check_pending)
1049{
1050 fstring key;
1051 time_t last_qscan_time, time_now = time(NULL);
1052 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1053 BOOL result = False;
1054
1055 if (!pdb)
1056 return False;
1057
1058 snprintf(key, sizeof(key), "CACHE/%s", sharename);
1059 last_qscan_time = (time_t)tdb_fetch_int32(pdb->tdb, key);
1060
1061 /*
1062 * Invalidate the queue for 3 reasons.
1063 * (1). last queue scan time == -1.
1064 * (2). Current time - last queue scan time > allowed cache time.
1065 * (3). last queue scan time > current time + MAX_CACHE_VALID_TIME (1 hour by default).
1066 * This last test picks up machines for which the clock has been moved
1067 * forward, an lpq scan done and then the clock moved back. Otherwise
1068 * that last lpq scan would stay around for a loooong loooong time... :-). JRA.
1069 */
1070
1071 if (last_qscan_time == ((time_t)-1)
1072 || (time_now - last_qscan_time) >= lp_lpqcachetime()
1073 || last_qscan_time > (time_now + MAX_CACHE_VALID_TIME))
1074 {
1075 uint32 u;
1076 time_t msg_pending_time;
1077
1078 DEBUG(4, ("print_cache_expired: cache expired for queue %s "
1079 "(last_qscan_time = %d, time now = %d, qcachetime = %d)\n",
1080 sharename, (int)last_qscan_time, (int)time_now,
1081 (int)lp_lpqcachetime() ));
1082
1083 /* check if another smbd has already sent a message to update the
1084 queue. Give the pending message one minute to clear and
1085 then send another message anyways. Make sure to check for
1086 clocks that have been run forward and then back again. */
1087
1088 snprintf(key, sizeof(key), "MSG_PENDING/%s", sharename);
1089
1090 if ( check_pending
1091 && tdb_fetch_uint32( pdb->tdb, key, &u )
1092 && (msg_pending_time=u) > 0
1093 && msg_pending_time <= time_now
1094 && (time_now - msg_pending_time) < 60 )
1095 {
1096 DEBUG(4,("print_cache_expired: message already pending for %s. Accepting cache\n",
1097 sharename));
1098 goto done;
1099 }
1100
1101 result = True;
1102 }
1103
1104done:
1105 release_print_db(pdb);
1106 return result;
1107}
1108
1109/****************************************************************************
1110 main work for updating the lpq cahe for a printer queue
1111****************************************************************************/
1112
1113static void print_queue_update_internal( const char *sharename,
1114 struct printif *current_printif,
1115 char *lpq_command, char *lprm_command )
1116{
1117 int i, qcount;
1118 print_queue_struct *queue = NULL;
1119 print_status_struct status;
1120 print_status_struct old_status;
1121 struct printjob *pjob;
1122 struct traverse_struct tstruct;
1123 TDB_DATA data, key;
1124 TDB_DATA jcdata;
1125 fstring keystr, cachestr;
1126 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1127
1128 if (!pdb) {
1129 return;
1130 }
1131
1132 DEBUG(5,("print_queue_update_internal: printer = %s, type = %d, lpq command = [%s]\n",
1133 sharename, current_printif->type, lpq_command));
1134
1135 /*
1136 * Update the cache time FIRST ! Stops others even
1137 * attempting to get the lock and doing this
1138 * if the lpq takes a long time.
1139 */
1140
1141 slprintf(cachestr, sizeof(cachestr)-1, "CACHE/%s", sharename);
1142 tdb_store_int32(pdb->tdb, cachestr, (int)time(NULL));
1143
1144 /* get the current queue using the appropriate interface */
1145 ZERO_STRUCT(status);
1146
1147 qcount = (*(current_printif->queue_get))(sharename,
1148 current_printif->type,
1149 lpq_command, &queue, &status);
1150
1151 DEBUG(3, ("print_queue_update_internal: %d job%s in queue for %s\n",
1152 qcount, (qcount != 1) ? "s" : "", sharename));
1153
1154 /* Sort the queue by submission time otherwise they are displayed
1155 in hash order. */
1156
1157 qsort(queue, qcount, sizeof(print_queue_struct),
1158 QSORT_CAST(printjob_comp));
1159
1160 /*
1161 any job in the internal database that is marked as spooled
1162 and doesn't exist in the system queue is considered finished
1163 and removed from the database
1164
1165 any job in the system database but not in the internal database
1166 is added as a unix job
1167
1168 fill in any system job numbers as we go
1169 */
1170
1171 jcdata = get_jobs_changed_data(pdb);
1172
1173 for (i=0; i<qcount; i++) {
1174 uint32 jobid = print_parse_jobid(queue[i].fs_file);
1175
1176 if (jobid == (uint32)-1) {
1177 /* assume its a unix print job */
1178 print_unix_job(sharename, &queue[i], jobid);
1179 continue;
1180 }
1181
1182 /* we have an active SMB print job - update its status */
1183 pjob = print_job_find(sharename, jobid);
1184 if (!pjob) {
1185 /* err, somethings wrong. Probably smbd was restarted
1186 with jobs in the queue. All we can do is treat them
1187 like unix jobs. Pity. */
1188 print_unix_job(sharename, &queue[i], jobid);
1189 continue;
1190 }
1191
1192 pjob->sysjob = queue[i].job;
1193
1194 /* don't reset the status on jobs to be deleted */
1195
1196 if ( pjob->status != LPQ_DELETING )
1197 pjob->status = queue[i].status;
1198
1199 pjob_store(sharename, jobid, pjob);
1200
1201 check_job_changed(sharename, jcdata, jobid);
1202 }
1203
1204 SAFE_FREE(jcdata.dptr);
1205
1206 /* now delete any queued entries that don't appear in the
1207 system queue */
1208 tstruct.queue = queue;
1209 tstruct.qcount = qcount;
1210 tstruct.snum = -1;
1211 tstruct.total_jobs = 0;
1212 tstruct.lpq_time = time(NULL);
1213 tstruct.sharename = sharename;
1214 tstruct.lprm_command = lprm_command;
1215 tstruct.print_if = current_printif;
1216
1217 tdb_traverse(pdb->tdb, traverse_fn_delete, (void *)&tstruct);
1218
1219 /* Store the linearised queue, max jobs only. */
1220 store_queue_struct(pdb, &tstruct);
1221
1222 SAFE_FREE(tstruct.queue);
1223
1224 DEBUG(10,("print_queue_update_internal: printer %s INFO/total_jobs = %d\n",
1225 sharename, tstruct.total_jobs ));
1226
1227 tdb_store_int32(pdb->tdb, "INFO/total_jobs", tstruct.total_jobs);
1228
1229 get_queue_status(sharename, &old_status);
1230 if (old_status.qcount != qcount)
1231 DEBUG(10,("print_queue_update_internal: queue status change %d jobs -> %d jobs for printer %s\n",
1232 old_status.qcount, qcount, sharename));
1233
1234 /* store the new queue status structure */
1235 slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", sharename);
1236 key.dptr = keystr;
1237 key.dsize = strlen(keystr);
1238
1239 status.qcount = qcount;
1240 data.dptr = (char *)&status;
1241 data.dsize = sizeof(status);
1242 tdb_store(pdb->tdb, key, data, TDB_REPLACE);
1243
1244 /*
1245 * Update the cache time again. We want to do this call
1246 * as little as possible...
1247 */
1248
1249 slprintf(keystr, sizeof(keystr)-1, "CACHE/%s", sharename);
1250 tdb_store_int32(pdb->tdb, keystr, (int32)time(NULL));
1251
1252 /* clear the msg pending record for this queue */
1253
1254 snprintf(keystr, sizeof(keystr), "MSG_PENDING/%s", sharename);
1255
1256 if ( !tdb_store_uint32( pdb->tdb, keystr, 0 ) ) {
1257 /* log a message but continue on */
1258
1259 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1260 sharename));
1261 }
1262
1263 release_print_db( pdb );
1264
1265 return;
1266}
1267
1268/****************************************************************************
1269 Update the internal database from the system print queue for a queue.
1270 obtain a lock on the print queue before proceeding (needed when mutiple
1271 smbd processes maytry to update the lpq cache concurrently).
1272****************************************************************************/
1273
1274static void print_queue_update_with_lock( const char *sharename,
1275 struct printif *current_printif,
1276 char *lpq_command, char *lprm_command )
1277{
1278 fstring keystr;
1279 struct tdb_print_db *pdb;
1280
1281 DEBUG(5,("print_queue_update_with_lock: printer share = %s\n", sharename));
1282 pdb = get_print_db_byname(sharename);
1283 if (!pdb)
1284 return;
1285
1286 if ( !print_cache_expired(sharename, False) ) {
1287 DEBUG(5,("print_queue_update_with_lock: print cache for %s is still ok\n", sharename));
1288 release_print_db(pdb);
1289 return;
1290 }
1291
1292 /*
1293 * Check to see if someone else is doing this update.
1294 * This is essentially a mutex on the update.
1295 */
1296
1297 if (get_updating_pid(sharename) != -1) {
1298 release_print_db(pdb);
1299 return;
1300 }
1301
1302 /* Lock the queue for the database update */
1303
1304 slprintf(keystr, sizeof(keystr) - 1, "LOCK/%s", sharename);
1305 /* Only wait 10 seconds for this. */
1306 if (tdb_lock_bystring_with_timeout(pdb->tdb, keystr, 10) == -1) {
1307 DEBUG(0,("print_queue_update_with_lock: Failed to lock printer %s database\n", sharename));
1308 release_print_db(pdb);
1309 return;
1310 }
1311
1312 /*
1313 * Ensure that no one else got in here.
1314 * If the updating pid is still -1 then we are
1315 * the winner.
1316 */
1317
1318 if (get_updating_pid(sharename) != -1) {
1319 /*
1320 * Someone else is doing the update, exit.
1321 */
1322 tdb_unlock_bystring(pdb->tdb, keystr);
1323 release_print_db(pdb);
1324 return;
1325 }
1326
1327 /*
1328 * We're going to do the update ourselves.
1329 */
1330
1331 /* Tell others we're doing the update. */
1332 set_updating_pid(sharename, True);
1333
1334 /*
1335 * Allow others to enter and notice we're doing
1336 * the update.
1337 */
1338
1339 tdb_unlock_bystring(pdb->tdb, keystr);
1340
1341 /* do the main work now */
1342
1343 print_queue_update_internal( sharename, current_printif,
1344 lpq_command, lprm_command );
1345
1346 /* Delete our pid from the db. */
1347 set_updating_pid(sharename, False);
1348 release_print_db(pdb);
1349}
1350
1351/****************************************************************************
1352this is the receive function of the background lpq updater
1353****************************************************************************/
1354static void print_queue_receive(int msg_type, struct process_id src,
1355 void *buf, size_t msglen,
1356 void *private_data)
1357{
1358 fstring sharename;
1359 pstring lpqcommand, lprmcommand;
1360 int printing_type;
1361 size_t len;
1362
1363 len = tdb_unpack( (char *)buf, msglen, "fdPP",
1364 sharename,
1365 &printing_type,
1366 lpqcommand,
1367 lprmcommand );
1368
1369 if ( len == -1 ) {
1370 DEBUG(0,("print_queue_receive: Got invalid print queue update message\n"));
1371 return;
1372 }
1373
1374 print_queue_update_with_lock(sharename,
1375 get_printer_fns_from_type((enum printing_types)printing_type),
1376 lpqcommand, lprmcommand );
1377
1378 return;
1379}
1380
1381static pid_t background_lpq_updater_pid = -1;
1382
1383/****************************************************************************
1384main thread of the background lpq updater
1385****************************************************************************/
1386void start_background_queue(void)
1387{
1388 DEBUG(3,("start_background_queue: Starting background LPQ thread\n"));
1389 background_lpq_updater_pid = sys_fork();
1390
1391 if (background_lpq_updater_pid == -1) {
1392 DEBUG(5,("start_background_queue: background LPQ thread failed to start. %s\n", strerror(errno) ));
1393 exit(1);
1394 }
1395
1396 if(background_lpq_updater_pid == 0) {
1397 /* Child. */
1398 DEBUG(5,("start_background_queue: background LPQ thread started\n"));
1399
1400 claim_connection( NULL, "smbd lpq backend", 0, False,
1401 FLAG_MSG_GENERAL|FLAG_MSG_SMBD|FLAG_MSG_PRINT_GENERAL);
1402
1403 if (!locking_init(0)) {
1404 exit(1);
1405 }
1406
1407 message_register(MSG_PRINTER_UPDATE, print_queue_receive,
1408 NULL);
1409
1410 DEBUG(5,("start_background_queue: background LPQ thread waiting for messages\n"));
1411 while (1) {
1412 pause();
1413
1414 /* check for some essential signals first */
1415
1416 if (got_sig_term) {
1417 exit_server_cleanly(NULL);
1418 }
1419
1420 if (reload_after_sighup) {
1421 change_to_root_user();
1422 DEBUG(1,("Reloading services after SIGHUP\n"));
1423 reload_services(False);
1424 reload_after_sighup = 0;
1425 }
1426
1427 /* now check for messages */
1428
1429 DEBUG(10,("start_background_queue: background LPQ thread got a message\n"));
1430 message_dispatch();
1431
1432 /* process any pending print change notify messages */
1433
1434 print_notify_send_messages(0);
1435 }
1436 }
1437}
1438
1439/****************************************************************************
1440update the internal database from the system print queue for a queue
1441****************************************************************************/
1442
1443static void print_queue_update(int snum, BOOL force)
1444{
1445 fstring key;
1446 fstring sharename;
1447 pstring lpqcommand, lprmcommand;
1448 char *buffer = NULL;
1449 size_t len = 0;
1450 size_t newlen;
1451 struct tdb_print_db *pdb;
1452 int type;
1453 struct printif *current_printif;
1454
1455 fstrcpy( sharename, lp_const_servicename(snum));
1456
1457 /* don't strip out characters like '$' from the printername */
1458
1459 pstrcpy( lpqcommand, lp_lpqcommand(snum));
1460 string_sub2( lpqcommand, "%p", PRINTERNAME(snum), sizeof(lpqcommand),
1461 False, False, False );
1462 standard_sub_advanced(lp_servicename(snum),
1463 current_user_info.unix_name, "",
1464 current_user.ut.gid,
1465 get_current_username(),
1466 current_user_info.domain,
1467 lpqcommand, sizeof(lpqcommand) );
1468
1469 pstrcpy( lprmcommand, lp_lprmcommand(snum));
1470 string_sub2( lprmcommand, "%p", PRINTERNAME(snum), sizeof(lprmcommand),
1471 False, False, False );
1472 standard_sub_advanced(lp_servicename(snum),
1473 current_user_info.unix_name, "",
1474 current_user.ut.gid,
1475 get_current_username(),
1476 current_user_info.domain,
1477 lprmcommand, sizeof(lprmcommand) );
1478
1479 /*
1480 * Make sure that the background queue process exists.
1481 * Otherwise just do the update ourselves
1482 */
1483
1484 if ( force || background_lpq_updater_pid == -1 ) {
1485 DEBUG(4,("print_queue_update: updating queue [%s] myself\n", sharename));
1486 current_printif = get_printer_fns( snum );
1487 print_queue_update_with_lock( sharename, current_printif, lpqcommand, lprmcommand );
1488
1489 return;
1490 }
1491
1492 type = lp_printing(snum);
1493
1494 /* get the length */
1495
1496 len = tdb_pack( NULL, 0, "fdPP",
1497 sharename,
1498 type,
1499 lpqcommand,
1500 lprmcommand );
1501
1502 buffer = SMB_XMALLOC_ARRAY( char, len );
1503
1504 /* now pack the buffer */
1505 newlen = tdb_pack( buffer, len, "fdPP",
1506 sharename,
1507 type,
1508 lpqcommand,
1509 lprmcommand );
1510
1511 SMB_ASSERT( newlen == len );
1512
1513 DEBUG(10,("print_queue_update: Sending message -> printer = %s, "
1514 "type = %d, lpq command = [%s] lprm command = [%s]\n",
1515 sharename, type, lpqcommand, lprmcommand ));
1516
1517 /* here we set a msg pending record for other smbd processes
1518 to throttle the number of duplicate print_queue_update msgs
1519 sent. */
1520
1521 pdb = get_print_db_byname(sharename);
1522 if (!pdb) {
1523 SAFE_FREE(buffer);
1524 return;
1525 }
1526
1527 snprintf(key, sizeof(key), "MSG_PENDING/%s", sharename);
1528
1529 if ( !tdb_store_uint32( pdb->tdb, key, time(NULL) ) ) {
1530 /* log a message but continue on */
1531
1532 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1533 sharename));
1534 }
1535
1536 release_print_db( pdb );
1537
1538 /* finally send the message */
1539
1540 message_send_pid(pid_to_procid(background_lpq_updater_pid),
1541 MSG_PRINTER_UPDATE, buffer, len, False);
1542
1543 SAFE_FREE( buffer );
1544
1545 return;
1546}
1547
1548/****************************************************************************
1549 Create/Update an entry in the print tdb that will allow us to send notify
1550 updates only to interested smbd's.
1551****************************************************************************/
1552
1553BOOL print_notify_register_pid(int snum)
1554{
1555 TDB_DATA data;
1556 struct tdb_print_db *pdb = NULL;
1557 TDB_CONTEXT *tdb = NULL;
1558 const char *printername;
1559 uint32 mypid = (uint32)sys_getpid();
1560 BOOL ret = False;
1561 size_t i;
1562
1563 /* if (snum == -1), then the change notify request was
1564 on a print server handle and we need to register on
1565 all print queus */
1566
1567 if (snum == -1)
1568 {
1569 int num_services = lp_numservices();
1570 int idx;
1571
1572 for ( idx=0; idx<num_services; idx++ ) {
1573 if (lp_snum_ok(idx) && lp_print_ok(idx) )
1574 print_notify_register_pid(idx);
1575 }
1576
1577 return True;
1578 }
1579 else /* register for a specific printer */
1580 {
1581 printername = lp_const_servicename(snum);
1582 pdb = get_print_db_byname(printername);
1583 if (!pdb)
1584 return False;
1585 tdb = pdb->tdb;
1586 }
1587
1588 if (tdb_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) == -1) {
1589 DEBUG(0,("print_notify_register_pid: Failed to lock printer %s\n",
1590 printername));
1591 if (pdb)
1592 release_print_db(pdb);
1593 return False;
1594 }
1595
1596 data = get_printer_notify_pid_list( tdb, printername, True );
1597
1598 /* Add ourselves and increase the refcount. */
1599
1600 for (i = 0; i < data.dsize; i += 8) {
1601 if (IVAL(data.dptr,i) == mypid) {
1602 uint32 new_refcount = IVAL(data.dptr, i+4) + 1;
1603 SIVAL(data.dptr, i+4, new_refcount);
1604 break;
1605 }
1606 }
1607
1608 if (i == data.dsize) {
1609 /* We weren't in the list. Realloc. */
1610 data.dptr = (char *)SMB_REALLOC(data.dptr, data.dsize + 8);
1611 if (!data.dptr) {
1612 DEBUG(0,("print_notify_register_pid: Relloc fail for printer %s\n",
1613 printername));
1614 goto done;
1615 }
1616 data.dsize += 8;
1617 SIVAL(data.dptr,data.dsize - 8,mypid);
1618 SIVAL(data.dptr,data.dsize - 4,1); /* Refcount. */
1619 }
1620
1621 /* Store back the record. */
1622 if (tdb_store_bystring(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) == -1) {
1623 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1624list for printer %s\n", printername));
1625 goto done;
1626 }
1627
1628 ret = True;
1629
1630 done:
1631
1632 tdb_unlock_bystring(tdb, NOTIFY_PID_LIST_KEY);
1633 if (pdb)
1634 release_print_db(pdb);
1635 SAFE_FREE(data.dptr);
1636 return ret;
1637}
1638
1639/****************************************************************************
1640 Update an entry in the print tdb that will allow us to send notify
1641 updates only to interested smbd's.
1642****************************************************************************/
1643
1644BOOL print_notify_deregister_pid(int snum)
1645{
1646 TDB_DATA data;
1647 struct tdb_print_db *pdb = NULL;
1648 TDB_CONTEXT *tdb = NULL;
1649 const char *printername;
1650 uint32 mypid = (uint32)sys_getpid();
1651 size_t i;
1652 BOOL ret = False;
1653
1654 /* if ( snum == -1 ), we are deregister a print server handle
1655 which means to deregister on all print queues */
1656
1657 if (snum == -1)
1658 {
1659 int num_services = lp_numservices();
1660 int idx;
1661
1662 for ( idx=0; idx<num_services; idx++ ) {
1663 if ( lp_snum_ok(idx) && lp_print_ok(idx) )
1664 print_notify_deregister_pid(idx);
1665 }
1666
1667 return True;
1668 }
1669 else /* deregister a specific printer */
1670 {
1671 printername = lp_const_servicename(snum);
1672 pdb = get_print_db_byname(printername);
1673 if (!pdb)
1674 return False;
1675 tdb = pdb->tdb;
1676 }
1677
1678 if (tdb_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) == -1) {
1679 DEBUG(0,("print_notify_register_pid: Failed to lock \
1680printer %s database\n", printername));
1681 if (pdb)
1682 release_print_db(pdb);
1683 return False;
1684 }
1685
1686 data = get_printer_notify_pid_list( tdb, printername, True );
1687
1688 /* Reduce refcount. Remove ourselves if zero. */
1689
1690 for (i = 0; i < data.dsize; ) {
1691 if (IVAL(data.dptr,i) == mypid) {
1692 uint32 refcount = IVAL(data.dptr, i+4);
1693
1694 refcount--;
1695
1696 if (refcount == 0) {
1697 if (data.dsize - i > 8)
1698 memmove( &data.dptr[i], &data.dptr[i+8], data.dsize - i - 8);
1699 data.dsize -= 8;
1700 continue;
1701 }
1702 SIVAL(data.dptr, i+4, refcount);
1703 }
1704
1705 i += 8;
1706 }
1707
1708 if (data.dsize == 0)
1709 SAFE_FREE(data.dptr);
1710
1711 /* Store back the record. */
1712 if (tdb_store_bystring(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) == -1) {
1713 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1714list for printer %s\n", printername));
1715 goto done;
1716 }
1717
1718 ret = True;
1719
1720 done:
1721
1722 tdb_unlock_bystring(tdb, NOTIFY_PID_LIST_KEY);
1723 if (pdb)
1724 release_print_db(pdb);
1725 SAFE_FREE(data.dptr);
1726 return ret;
1727}
1728
1729/****************************************************************************
1730 Check if a jobid is valid. It is valid if it exists in the database.
1731****************************************************************************/
1732
1733BOOL print_job_exists(const char* sharename, uint32 jobid)
1734{
1735 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1736 BOOL ret;
1737
1738 if (!pdb)
1739 return False;
1740 ret = tdb_exists(pdb->tdb, print_key(jobid));
1741 release_print_db(pdb);
1742 return ret;
1743}
1744
1745/****************************************************************************
1746 Give the fd used for a jobid.
1747****************************************************************************/
1748
1749int print_job_fd(const char* sharename, uint32 jobid)
1750{
1751 struct printjob *pjob = print_job_find(sharename, jobid);
1752 if (!pjob)
1753 return -1;
1754 /* don't allow another process to get this info - it is meaningless */
1755 if (pjob->pid != sys_getpid())
1756 return -1;
1757 return pjob->fd;
1758}
1759
1760/****************************************************************************
1761 Give the filename used for a jobid.
1762 Only valid for the process doing the spooling and when the job
1763 has not been spooled.
1764****************************************************************************/
1765
1766char *print_job_fname(const char* sharename, uint32 jobid)
1767{
1768 struct printjob *pjob = print_job_find(sharename, jobid);
1769 if (!pjob || pjob->spooled || pjob->pid != sys_getpid())
1770 return NULL;
1771 return pjob->filename;
1772}
1773
1774
1775/****************************************************************************
1776 Give the filename used for a jobid.
1777 Only valid for the process doing the spooling and when the job
1778 has not been spooled.
1779****************************************************************************/
1780
1781NT_DEVICEMODE *print_job_devmode(const char* sharename, uint32 jobid)
1782{
1783 struct printjob *pjob = print_job_find(sharename, jobid);
1784
1785 if ( !pjob )
1786 return NULL;
1787
1788 return pjob->nt_devmode;
1789}
1790
1791/****************************************************************************
1792 Set the place in the queue for a job.
1793****************************************************************************/
1794
1795BOOL print_job_set_place(const char *sharename, uint32 jobid, int place)
1796{
1797 DEBUG(2,("print_job_set_place not implemented yet\n"));
1798 return False;
1799}
1800
1801/****************************************************************************
1802 Set the name of a job. Only possible for owner.
1803****************************************************************************/
1804
1805BOOL print_job_set_name(const char *sharename, uint32 jobid, char *name)
1806{
1807 struct printjob *pjob;
1808
1809 pjob = print_job_find(sharename, jobid);
1810 if (!pjob || pjob->pid != sys_getpid())
1811 return False;
1812
1813 fstrcpy(pjob->jobname, name);
1814 return pjob_store(sharename, jobid, pjob);
1815}
1816
1817/***************************************************************************
1818 Remove a jobid from the 'jobs changed' list.
1819***************************************************************************/
1820
1821static BOOL remove_from_jobs_changed(const char* sharename, uint32 jobid)
1822{
1823 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1824 TDB_DATA data, key;
1825 size_t job_count, i;
1826 BOOL ret = False;
1827 BOOL gotlock = False;
1828
1829 if (!pdb) {
1830 return False;
1831 }
1832
1833 ZERO_STRUCT(data);
1834
1835 key = string_tdb_data("INFO/jobs_changed");
1836
1837 if (tdb_chainlock_with_timeout(pdb->tdb, key, 5) == -1)
1838 goto out;
1839
1840 gotlock = True;
1841
1842 data = tdb_fetch(pdb->tdb, key);
1843
1844 if (data.dptr == NULL || data.dsize == 0 || (data.dsize % 4 != 0))
1845 goto out;
1846
1847 job_count = data.dsize / 4;
1848 for (i = 0; i < job_count; i++) {
1849 uint32 ch_jobid;
1850
1851 ch_jobid = IVAL(data.dptr, i*4);
1852 if (ch_jobid == jobid) {
1853 if (i < job_count -1 )
1854 memmove(data.dptr + (i*4), data.dptr + (i*4) + 4, (job_count - i - 1)*4 );
1855 data.dsize -= 4;
1856 if (tdb_store(pdb->tdb, key, data, TDB_REPLACE) == -1)
1857 goto out;
1858 break;
1859 }
1860 }
1861
1862 ret = True;
1863 out:
1864
1865 if (gotlock)
1866 tdb_chainunlock(pdb->tdb, key);
1867 SAFE_FREE(data.dptr);
1868 release_print_db(pdb);
1869 if (ret)
1870 DEBUG(10,("remove_from_jobs_changed: removed jobid %u\n", (unsigned int)jobid ));
1871 else
1872 DEBUG(10,("remove_from_jobs_changed: Failed to remove jobid %u\n", (unsigned int)jobid ));
1873 return ret;
1874}
1875
1876/****************************************************************************
1877 Delete a print job - don't update queue.
1878****************************************************************************/
1879
1880static BOOL print_job_delete1(int snum, uint32 jobid)
1881{
1882 const char* sharename = lp_const_servicename(snum);
1883 struct printjob *pjob = print_job_find(sharename, jobid);
1884 int result = 0;
1885 struct printif *current_printif = get_printer_fns( snum );
1886
1887 if (!pjob)
1888 return False;
1889
1890 /*
1891 * If already deleting just return.
1892 */
1893
1894 if (pjob->status == LPQ_DELETING)
1895 return True;
1896
1897 /* Hrm - we need to be able to cope with deleting a job before it
1898 has reached the spooler. Just mark it as LPQ_DELETING and
1899 let the print_queue_update() code rmeove the record */
1900
1901
1902 if (pjob->sysjob == -1) {
1903 DEBUG(5, ("attempt to delete job %u not seen by lpr\n", (unsigned int)jobid));
1904 }
1905
1906 /* Set the tdb entry to be deleting. */
1907
1908 pjob->status = LPQ_DELETING;
1909 pjob_store(sharename, jobid, pjob);
1910
1911 if (pjob->spooled && pjob->sysjob != -1)
1912 {
1913 result = (*(current_printif->job_delete))(
1914 PRINTERNAME(snum),
1915 lp_lprmcommand(snum),
1916 pjob);
1917
1918 /* Delete the tdb entry if the delete succeeded or the job hasn't
1919 been spooled. */
1920
1921 if (result == 0) {
1922 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1923 int njobs = 1;
1924
1925 if (!pdb)
1926 return False;
1927 pjob_delete(sharename, jobid);
1928 /* Ensure we keep a rough count of the number of total jobs... */
1929 tdb_change_int32_atomic(pdb->tdb, "INFO/total_jobs", &njobs, -1);
1930 release_print_db(pdb);
1931 }
1932 }
1933
1934 remove_from_jobs_changed( sharename, jobid );
1935
1936 return (result == 0);
1937}
1938
1939/****************************************************************************
1940 Return true if the current user owns the print job.
1941****************************************************************************/
1942
1943static BOOL is_owner(struct current_user *user, const char *servicename,
1944 uint32 jobid)
1945{
1946 struct printjob *pjob = print_job_find(servicename, jobid);
1947 user_struct *vuser;
1948
1949 if (!pjob || !user)
1950 return False;
1951
1952 if ((vuser = get_valid_user_struct(user->vuid)) != NULL) {
1953 return strequal(pjob->user, vuser->user.smb_name);
1954 } else {
1955 return strequal(pjob->user, uidtoname(user->ut.uid));
1956 }
1957}
1958
1959/****************************************************************************
1960 Delete a print job.
1961****************************************************************************/
1962
1963BOOL print_job_delete(struct current_user *user, int snum, uint32 jobid, WERROR *errcode)
1964{
1965 const char* sharename = lp_const_servicename( snum );
1966 struct printjob *pjob;
1967 BOOL owner;
1968 char *fname;
1969
1970 *errcode = WERR_OK;
1971
1972 owner = is_owner(user, lp_const_servicename(snum), jobid);
1973
1974 /* Check access against security descriptor or whether the user
1975 owns their job. */
1976
1977 if (!owner &&
1978 !print_access_check(user, snum, JOB_ACCESS_ADMINISTER)) {
1979 DEBUG(3, ("delete denied by security descriptor\n"));
1980 *errcode = WERR_ACCESS_DENIED;
1981
1982 /* BEGIN_ADMIN_LOG */
1983 sys_adminlog( LOG_ERR,
1984 "Permission denied-- user not allowed to delete, \
1985pause, or resume print job. User name: %s. Printer name: %s.",
1986 uidtoname(user->ut.uid), PRINTERNAME(snum) );
1987 /* END_ADMIN_LOG */
1988
1989 return False;
1990 }
1991
1992 /*
1993 * get the spooled filename of the print job
1994 * if this works, then the file has not been spooled
1995 * to the underlying print system. Just delete the
1996 * spool file & return.
1997 */
1998
1999 if ( (fname = print_job_fname( sharename, jobid )) != NULL )
2000 {
2001 /* remove the spool file */
2002 DEBUG(10,("print_job_delete: Removing spool file [%s]\n", fname ));
2003 if ( unlink( fname ) == -1 ) {
2004 *errcode = map_werror_from_unix(errno);
2005 return False;
2006 }
2007 }
2008
2009 if (!print_job_delete1(snum, jobid)) {
2010 *errcode = WERR_ACCESS_DENIED;
2011 return False;
2012 }
2013
2014 /* force update the database and say the delete failed if the
2015 job still exists */
2016
2017 print_queue_update(snum, True);
2018
2019 pjob = print_job_find(sharename, jobid);
2020 if ( pjob && (pjob->status != LPQ_DELETING) )
2021 *errcode = WERR_ACCESS_DENIED;
2022
2023 return (pjob == NULL );
2024}
2025
2026/****************************************************************************
2027 Pause a job.
2028****************************************************************************/
2029
2030BOOL print_job_pause(struct current_user *user, int snum, uint32 jobid, WERROR *errcode)
2031{
2032 const char* sharename = lp_const_servicename(snum);
2033 struct printjob *pjob;
2034 int ret = -1;
2035 struct printif *current_printif = get_printer_fns( snum );
2036
2037 pjob = print_job_find(sharename, jobid);
2038
2039 if (!pjob || !user) {
2040 DEBUG(10, ("print_job_pause: no pjob or user for jobid %u\n",
2041 (unsigned int)jobid ));
2042 return False;
2043 }
2044
2045 if (!pjob->spooled || pjob->sysjob == -1) {
2046 DEBUG(10, ("print_job_pause: not spooled or bad sysjob = %d for jobid %u\n",
2047 (int)pjob->sysjob, (unsigned int)jobid ));
2048 return False;
2049 }
2050
2051 if (!is_owner(user, lp_const_servicename(snum), jobid) &&
2052 !print_access_check(user, snum, JOB_ACCESS_ADMINISTER)) {
2053 DEBUG(3, ("pause denied by security descriptor\n"));
2054
2055 /* BEGIN_ADMIN_LOG */
2056 sys_adminlog( LOG_ERR,
2057 "Permission denied-- user not allowed to delete, \
2058pause, or resume print job. User name: %s. Printer name: %s.",
2059 uidtoname(user->ut.uid), PRINTERNAME(snum) );
2060 /* END_ADMIN_LOG */
2061
2062 *errcode = WERR_ACCESS_DENIED;
2063 return False;
2064 }
2065
2066 /* need to pause the spooled entry */
2067 ret = (*(current_printif->job_pause))(snum, pjob);
2068
2069 if (ret != 0) {
2070 *errcode = WERR_INVALID_PARAM;
2071 return False;
2072 }
2073
2074 /* force update the database */
2075 print_cache_flush(lp_const_servicename(snum));
2076
2077 /* Send a printer notify message */
2078
2079 notify_job_status(sharename, jobid, JOB_STATUS_PAUSED);
2080
2081 /* how do we tell if this succeeded? */
2082
2083 return True;
2084}
2085
2086/****************************************************************************
2087 Resume a job.
2088****************************************************************************/
2089
2090BOOL print_job_resume(struct current_user *user, int snum, uint32 jobid, WERROR *errcode)
2091{
2092 const char *sharename = lp_const_servicename(snum);
2093 struct printjob *pjob;
2094 int ret;
2095 struct printif *current_printif = get_printer_fns( snum );
2096
2097 pjob = print_job_find(sharename, jobid);
2098
2099 if (!pjob || !user) {
2100 DEBUG(10, ("print_job_resume: no pjob or user for jobid %u\n",
2101 (unsigned int)jobid ));
2102 return False;
2103 }
2104
2105 if (!pjob->spooled || pjob->sysjob == -1) {
2106 DEBUG(10, ("print_job_resume: not spooled or bad sysjob = %d for jobid %u\n",
2107 (int)pjob->sysjob, (unsigned int)jobid ));
2108 return False;
2109 }
2110
2111 if (!is_owner(user, lp_const_servicename(snum), jobid) &&
2112 !print_access_check(user, snum, JOB_ACCESS_ADMINISTER)) {
2113 DEBUG(3, ("resume denied by security descriptor\n"));
2114 *errcode = WERR_ACCESS_DENIED;
2115
2116 /* BEGIN_ADMIN_LOG */
2117 sys_adminlog( LOG_ERR,
2118 "Permission denied-- user not allowed to delete, \
2119pause, or resume print job. User name: %s. Printer name: %s.",
2120 uidtoname(user->ut.uid), PRINTERNAME(snum) );
2121 /* END_ADMIN_LOG */
2122 return False;
2123 }
2124
2125 ret = (*(current_printif->job_resume))(snum, pjob);
2126
2127 if (ret != 0) {
2128 *errcode = WERR_INVALID_PARAM;
2129 return False;
2130 }
2131
2132 /* force update the database */
2133 print_cache_flush(lp_const_servicename(snum));
2134
2135 /* Send a printer notify message */
2136
2137 notify_job_status(sharename, jobid, JOB_STATUS_QUEUED);
2138
2139 return True;
2140}
2141
2142/****************************************************************************
2143 Write to a print file.
2144****************************************************************************/
2145
2146ssize_t print_job_write(int snum, uint32 jobid, const char *buf, SMB_OFF_T pos, size_t size)
2147{
2148 const char* sharename = lp_const_servicename(snum);
2149 int return_code;
2150 struct printjob *pjob;
2151
2152 pjob = print_job_find(sharename, jobid);
2153
2154 if (!pjob)
2155 return -1;
2156 /* don't allow another process to get this info - it is meaningless */
2157 if (pjob->pid != sys_getpid())
2158 return -1;
2159
2160 return_code = write_data_at_offset(pjob->fd, buf, size, pos);
2161
2162 if (return_code>0) {
2163 pjob->size += size;
2164 pjob_store(sharename, jobid, pjob);
2165 }
2166 return return_code;
2167}
2168
2169/****************************************************************************
2170 Get the queue status - do not update if db is out of date.
2171****************************************************************************/
2172
2173static int get_queue_status(const char* sharename, print_status_struct *status)
2174{
2175 fstring keystr;
2176 TDB_DATA data;
2177 struct tdb_print_db *pdb = get_print_db_byname(sharename);
2178 int len;
2179
2180 if (status) {
2181 ZERO_STRUCTP(status);
2182 }
2183
2184 if (!pdb)
2185 return 0;
2186
2187 if (status) {
2188 fstr_sprintf(keystr, "STATUS/%s", sharename);
2189 data = tdb_fetch(pdb->tdb, string_tdb_data(keystr));
2190 if (data.dptr) {
2191 if (data.dsize == sizeof(print_status_struct))
2192 /* this memcpy is ok since the status struct was
2193 not packed before storing it in the tdb */
2194 memcpy(status, data.dptr, sizeof(print_status_struct));
2195 SAFE_FREE(data.dptr);
2196 }
2197 }
2198 len = tdb_fetch_int32(pdb->tdb, "INFO/total_jobs");
2199 release_print_db(pdb);
2200 return (len == -1 ? 0 : len);
2201}
2202
2203/****************************************************************************
2204 Determine the number of jobs in a queue.
2205****************************************************************************/
2206
2207int print_queue_length(int snum, print_status_struct *pstatus)
2208{
2209 const char* sharename = lp_const_servicename( snum );
2210 print_status_struct status;
2211 int len;
2212
2213 ZERO_STRUCT( status );
2214
2215 /* make sure the database is up to date */
2216 if (print_cache_expired(lp_const_servicename(snum), True))
2217 print_queue_update(snum, False);
2218
2219 /* also fetch the queue status */
2220 memset(&status, 0, sizeof(status));
2221 len = get_queue_status(sharename, &status);
2222
2223 if (pstatus)
2224 *pstatus = status;
2225
2226 return len;
2227}
2228
2229/***************************************************************************
2230 Allocate a jobid. Hold the lock for as short a time as possible.
2231***************************************************************************/
2232
2233static BOOL allocate_print_jobid(struct tdb_print_db *pdb, int snum, const char *sharename, uint32 *pjobid)
2234{
2235 int i;
2236 uint32 jobid;
2237
2238 *pjobid = (uint32)-1;
2239
2240 for (i = 0; i < 3; i++) {
2241 /* Lock the database - only wait 20 seconds. */
2242 if (tdb_lock_bystring_with_timeout(pdb->tdb, "INFO/nextjob", 20) == -1) {
2243 DEBUG(0,("allocate_print_jobid: failed to lock printing database %s\n", sharename));
2244 return False;
2245 }
2246
2247 if (!tdb_fetch_uint32(pdb->tdb, "INFO/nextjob", &jobid)) {
2248 if (tdb_error(pdb->tdb) != TDB_ERR_NOEXIST) {
2249 DEBUG(0, ("allocate_print_jobid: failed to fetch INFO/nextjob for print queue %s\n",
2250 sharename));
2251 return False;
2252 }
2253 jobid = 0;
2254 }
2255
2256 jobid = NEXT_JOBID(jobid);
2257
2258 if (tdb_store_int32(pdb->tdb, "INFO/nextjob", jobid)==-1) {
2259 DEBUG(3, ("allocate_print_jobid: failed to store INFO/nextjob.\n"));
2260 tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
2261 return False;
2262 }
2263
2264 /* We've finished with the INFO/nextjob lock. */
2265 tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
2266
2267 if (!print_job_exists(sharename, jobid))
2268 break;
2269 }
2270
2271 if (i > 2) {
2272 DEBUG(0, ("allocate_print_jobid: failed to allocate a print job for queue %s\n",
2273 sharename));
2274 /* Probably full... */
2275 errno = ENOSPC;
2276 return False;
2277 }
2278
2279 /* Store a dummy placeholder. */
2280 {
2281 TDB_DATA dum;
2282 dum.dptr = NULL;
2283 dum.dsize = 0;
2284 if (tdb_store(pdb->tdb, print_key(jobid), dum, TDB_INSERT) == -1) {
2285 DEBUG(3, ("allocate_print_jobid: jobid (%d) failed to store placeholder.\n",
2286 jobid ));
2287 return False;
2288 }
2289 }
2290
2291 *pjobid = jobid;
2292 return True;
2293}
2294
2295/***************************************************************************
2296 Append a jobid to the 'jobs changed' list.
2297***************************************************************************/
2298
2299static BOOL add_to_jobs_changed(struct tdb_print_db *pdb, uint32 jobid)
2300{
2301 TDB_DATA data;
2302 uint32 store_jobid;
2303
2304 SIVAL(&store_jobid, 0, jobid);
2305 data.dptr = (char *)&store_jobid;
2306 data.dsize = 4;
2307
2308 DEBUG(10,("add_to_jobs_changed: Added jobid %u\n", (unsigned int)jobid ));
2309
2310 return (tdb_append(pdb->tdb, string_tdb_data("INFO/jobs_changed"),
2311 data) == 0);
2312}
2313
2314/***************************************************************************
2315 Start spooling a job - return the jobid.
2316***************************************************************************/
2317
2318uint32 print_job_start(struct current_user *user, int snum, char *jobname, NT_DEVICEMODE *nt_devmode )
2319{
2320 uint32 jobid;
2321 char *path;
2322 struct printjob pjob;
2323 user_struct *vuser;
2324 const char *sharename = lp_const_servicename(snum);
2325 struct tdb_print_db *pdb = get_print_db_byname(sharename);
2326 int njobs;
2327
2328 errno = 0;
2329
2330 if (!pdb)
2331 return (uint32)-1;
2332
2333 if (!print_access_check(user, snum, PRINTER_ACCESS_USE)) {
2334 DEBUG(3, ("print_job_start: job start denied by security descriptor\n"));
2335 release_print_db(pdb);
2336 return (uint32)-1;
2337 }
2338
2339 if (!print_time_access_check(lp_servicename(snum))) {
2340 DEBUG(3, ("print_job_start: job start denied by time check\n"));
2341 release_print_db(pdb);
2342 return (uint32)-1;
2343 }
2344
2345 path = lp_pathname(snum);
2346
2347 /* see if we have sufficient disk space */
2348 if (lp_minprintspace(snum)) {
2349 SMB_BIG_UINT dspace, dsize;
2350 if (sys_fsusage(path, &dspace, &dsize) == 0 &&
2351 dspace < 2*(SMB_BIG_UINT)lp_minprintspace(snum)) {
2352 DEBUG(3, ("print_job_start: disk space check failed.\n"));
2353 release_print_db(pdb);
2354 errno = ENOSPC;
2355 return (uint32)-1;
2356 }
2357 }
2358
2359 /* for autoloaded printers, check that the printcap entry still exists */
2360 if (lp_autoloaded(snum) && !pcap_printername_ok(lp_const_servicename(snum))) {
2361 DEBUG(3, ("print_job_start: printer name %s check failed.\n", lp_const_servicename(snum) ));
2362 release_print_db(pdb);
2363 errno = ENOENT;
2364 return (uint32)-1;
2365 }
2366
2367 /* Insure the maximum queue size is not violated */
2368 if ((njobs = print_queue_length(snum,NULL)) > lp_maxprintjobs(snum)) {
2369 DEBUG(3, ("print_job_start: Queue %s number of jobs (%d) larger than max printjobs per queue (%d).\n",
2370 sharename, njobs, lp_maxprintjobs(snum) ));
2371 release_print_db(pdb);
2372 errno = ENOSPC;
2373 return (uint32)-1;
2374 }
2375
2376 DEBUG(10,("print_job_start: Queue %s number of jobs (%d), max printjobs = %d\n",
2377 sharename, njobs, lp_maxprintjobs(snum) ));
2378
2379 if (!allocate_print_jobid(pdb, snum, sharename, &jobid))
2380 goto fail;
2381
2382 /* create the database entry */
2383
2384 ZERO_STRUCT(pjob);
2385
2386 pjob.pid = sys_getpid();
2387 pjob.sysjob = -1;
2388 pjob.fd = -1;
2389 pjob.starttime = time(NULL);
2390 pjob.status = LPQ_SPOOLING;
2391 pjob.size = 0;
2392 pjob.spooled = False;
2393 pjob.smbjob = True;
2394 pjob.nt_devmode = nt_devmode;
2395
2396 fstrcpy(pjob.jobname, jobname);
2397
2398 if ((vuser = get_valid_user_struct(user->vuid)) != NULL) {
2399 fstrcpy(pjob.user, lp_printjob_username(snum));
[158]2400 standard_sub_advanced(sharename, vuser->user.smb_name, path,
2401 vuser->gid, vuser->user.smb_name,
2402 vuser->user.domain, pjob.user,
2403 sizeof(pjob.user) - 1);
[134]2404 /* ensure NULL termination */
2405 pjob.user[sizeof(pjob.user)-1] = '\0';
2406 } else {
2407 fstrcpy(pjob.user, uidtoname(user->ut.uid));
2408 }
2409
2410 fstrcpy(pjob.queuename, lp_const_servicename(snum));
2411
2412 /* we have a job entry - now create the spool file */
2413 slprintf(pjob.filename, sizeof(pjob.filename)-1, "%s/%s%.8u.XXXXXX",
2414 path, PRINT_SPOOL_PREFIX, (unsigned int)jobid);
2415 pjob.fd = smb_mkstemp(pjob.filename);
2416
2417 if (pjob.fd == -1) {
2418 if (errno == EACCES) {
2419 /* Common setup error, force a report. */
2420 DEBUG(0, ("print_job_start: insufficient permissions \
2421to open spool file %s.\n", pjob.filename));
2422 } else {
2423 /* Normal case, report at level 3 and above. */
2424 DEBUG(3, ("print_job_start: can't open spool file %s,\n", pjob.filename));
2425 DEBUGADD(3, ("errno = %d (%s).\n", errno, strerror(errno)));
2426 }
2427 goto fail;
2428 }
2429
2430 pjob_store(sharename, jobid, &pjob);
2431
2432 /* Update the 'jobs changed' entry used by print_queue_status. */
2433 add_to_jobs_changed(pdb, jobid);
2434
2435 /* Ensure we keep a rough count of the number of total jobs... */
2436 tdb_change_int32_atomic(pdb->tdb, "INFO/total_jobs", &njobs, 1);
2437
2438 release_print_db(pdb);
2439
2440 return jobid;
2441
2442 fail:
2443 if (jobid != -1)
2444 pjob_delete(sharename, jobid);
2445
2446 release_print_db(pdb);
2447
2448 DEBUG(3, ("print_job_start: returning fail. Error = %s\n", strerror(errno) ));
2449 return (uint32)-1;
2450}
2451
2452/****************************************************************************
2453 Update the number of pages spooled to jobid
2454****************************************************************************/
2455
2456void print_job_endpage(int snum, uint32 jobid)
2457{
2458 const char* sharename = lp_const_servicename(snum);
2459 struct printjob *pjob;
2460
2461 pjob = print_job_find(sharename, jobid);
2462 if (!pjob)
2463 return;
2464 /* don't allow another process to get this info - it is meaningless */
2465 if (pjob->pid != sys_getpid())
2466 return;
2467
2468 pjob->page_count++;
2469 pjob_store(sharename, jobid, pjob);
2470}
2471
2472/****************************************************************************
2473 Print a file - called on closing the file. This spools the job.
2474 If normal close is false then we're tearing down the jobs - treat as an
2475 error.
2476****************************************************************************/
2477
2478BOOL print_job_end(int snum, uint32 jobid, enum file_close_type close_type)
2479{
2480 const char* sharename = lp_const_servicename(snum);
2481 struct printjob *pjob;
2482 int ret;
2483 SMB_STRUCT_STAT sbuf;
2484 struct printif *current_printif = get_printer_fns( snum );
2485
2486 pjob = print_job_find(sharename, jobid);
2487
2488 if (!pjob)
2489 return False;
2490
2491 if (pjob->spooled || pjob->pid != sys_getpid())
2492 return False;
2493
2494 if ((close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) &&
2495 (sys_fstat(pjob->fd, &sbuf) == 0)) {
2496 pjob->size = sbuf.st_size;
2497 close(pjob->fd);
2498 pjob->fd = -1;
2499 } else {
2500
2501 /*
2502 * Not a normal close or we couldn't stat the job file,
2503 * so something has gone wrong. Cleanup.
2504 */
2505 close(pjob->fd);
2506 pjob->fd = -1;
2507 DEBUG(3,("print_job_end: failed to stat file for jobid %d\n", jobid ));
2508 goto fail;
2509 }
2510
2511 /* Technically, this is not quite right. If the printer has a separator
2512 * page turned on, the NT spooler prints the separator page even if the
2513 * print job is 0 bytes. 010215 JRR */
2514 if (pjob->size == 0 || pjob->status == LPQ_DELETING) {
2515 /* don't bother spooling empty files or something being deleted. */
2516 DEBUG(5,("print_job_end: canceling spool of %s (%s)\n",
2517 pjob->filename, pjob->size ? "deleted" : "zero length" ));
2518 unlink(pjob->filename);
2519 pjob_delete(sharename, jobid);
2520 return True;
2521 }
2522
2523 pjob->smbjob = jobid;
2524
2525 ret = (*(current_printif->job_submit))(snum, pjob);
2526
2527 if (ret)
2528 goto fail;
2529
2530 /* The print job has been successfully handed over to the back-end */
2531
2532 pjob->spooled = True;
2533 pjob->status = LPQ_QUEUED;
2534 pjob_store(sharename, jobid, pjob);
2535
2536 /* make sure the database is up to date */
2537 if (print_cache_expired(lp_const_servicename(snum), True))
2538 print_queue_update(snum, False);
2539
2540 return True;
2541
2542fail:
2543
2544 /* The print job was not successfully started. Cleanup */
2545 /* Still need to add proper error return propagation! 010122:JRR */
2546 unlink(pjob->filename);
2547 pjob_delete(sharename, jobid);
2548 return False;
2549}
2550
2551/****************************************************************************
2552 Get a snapshot of jobs in the system without traversing.
2553****************************************************************************/
2554
2555static BOOL get_stored_queue_info(struct tdb_print_db *pdb, int snum, int *pcount, print_queue_struct **ppqueue)
2556{
2557 TDB_DATA data, cgdata;
2558 print_queue_struct *queue = NULL;
2559 uint32 qcount = 0;
2560 uint32 extra_count = 0;
2561 int total_count = 0;
2562 size_t len = 0;
2563 uint32 i;
2564 int max_reported_jobs = lp_max_reported_jobs(snum);
2565 BOOL ret = False;
2566 const char* sharename = lp_servicename(snum);
2567
2568 /* make sure the database is up to date */
2569 if (print_cache_expired(lp_const_servicename(snum), True))
2570 print_queue_update(snum, False);
2571
2572 *pcount = 0;
2573 *ppqueue = NULL;
2574
2575 ZERO_STRUCT(data);
2576 ZERO_STRUCT(cgdata);
2577
2578 /* Get the stored queue data. */
2579 data = tdb_fetch(pdb->tdb, string_tdb_data("INFO/linear_queue_array"));
2580
2581 if (data.dptr && data.dsize >= sizeof(qcount))
2582 len += tdb_unpack(data.dptr + len, data.dsize - len, "d", &qcount);
2583
2584 /* Get the changed jobs list. */
2585 cgdata = tdb_fetch(pdb->tdb, string_tdb_data("INFO/jobs_changed"));
2586 if (cgdata.dptr != NULL && (cgdata.dsize % 4 == 0))
2587 extra_count = cgdata.dsize/4;
2588
2589 DEBUG(5,("get_stored_queue_info: qcount = %u, extra_count = %u\n", (unsigned int)qcount, (unsigned int)extra_count));
2590
2591 /* Allocate the queue size. */
2592 if (qcount == 0 && extra_count == 0)
2593 goto out;
2594
2595 if ((queue = SMB_MALLOC_ARRAY(print_queue_struct, qcount + extra_count)) == NULL)
2596 goto out;
2597
2598 /* Retrieve the linearised queue data. */
2599
2600 for( i = 0; i < qcount; i++) {
2601 uint32 qjob, qsize, qpage_count, qstatus, qpriority, qtime;
2602 len += tdb_unpack(data.dptr + len, data.dsize - len, "ddddddff",
2603 &qjob,
2604 &qsize,
2605 &qpage_count,
2606 &qstatus,
2607 &qpriority,
2608 &qtime,
2609 queue[i].fs_user,
2610 queue[i].fs_file);
2611 queue[i].job = qjob;
2612 queue[i].size = qsize;
2613 queue[i].page_count = qpage_count;
2614 queue[i].status = qstatus;
2615 queue[i].priority = qpriority;
2616 queue[i].time = qtime;
2617 }
2618
2619 total_count = qcount;
2620
2621 /* Add in the changed jobids. */
2622 for( i = 0; i < extra_count; i++) {
2623 uint32 jobid;
2624 struct printjob *pjob;
2625
2626 jobid = IVAL(cgdata.dptr, i*4);
2627 DEBUG(5,("get_stored_queue_info: changed job = %u\n", (unsigned int)jobid));
2628 pjob = print_job_find(lp_const_servicename(snum), jobid);
2629 if (!pjob) {
2630 DEBUG(5,("get_stored_queue_info: failed to find changed job = %u\n", (unsigned int)jobid));
2631 remove_from_jobs_changed(sharename, jobid);
2632 continue;
2633 }
2634
2635 queue[total_count].job = jobid;
2636 queue[total_count].size = pjob->size;
2637 queue[total_count].page_count = pjob->page_count;
2638 queue[total_count].status = pjob->status;
2639 queue[total_count].priority = 1;
2640 queue[total_count].time = pjob->starttime;
2641 fstrcpy(queue[total_count].fs_user, pjob->user);
2642 fstrcpy(queue[total_count].fs_file, pjob->jobname);
2643 total_count++;
2644 }
2645
2646 /* Sort the queue by submission time otherwise they are displayed
2647 in hash order. */
2648
2649 qsort(queue, total_count, sizeof(print_queue_struct), QSORT_CAST(printjob_comp));
2650
2651 DEBUG(5,("get_stored_queue_info: total_count = %u\n", (unsigned int)total_count));
2652
2653 if (max_reported_jobs && total_count > max_reported_jobs)
2654 total_count = max_reported_jobs;
2655
2656 *ppqueue = queue;
2657 *pcount = total_count;
2658
2659 ret = True;
2660
2661 out:
2662
2663 SAFE_FREE(data.dptr);
2664 SAFE_FREE(cgdata.dptr);
2665 return ret;
2666}
2667
2668/****************************************************************************
2669 Get a printer queue listing.
2670 set queue = NULL and status = NULL if you just want to update the cache
2671****************************************************************************/
2672
2673int print_queue_status(int snum,
2674 print_queue_struct **ppqueue,
2675 print_status_struct *status)
2676{
2677 fstring keystr;
2678 TDB_DATA data, key;
2679 const char *sharename;
2680 struct tdb_print_db *pdb;
2681 int count = 0;
2682
2683 /* make sure the database is up to date */
2684
2685 if (print_cache_expired(lp_const_servicename(snum), True))
2686 print_queue_update(snum, False);
2687
2688 /* return if we are done */
2689 if ( !ppqueue || !status )
2690 return 0;
2691
2692 *ppqueue = NULL;
2693 sharename = lp_const_servicename(snum);
2694 pdb = get_print_db_byname(sharename);
2695
2696 if (!pdb)
2697 return 0;
2698
2699 /*
2700 * Fetch the queue status. We must do this first, as there may
2701 * be no jobs in the queue.
2702 */
2703
2704 ZERO_STRUCTP(status);
2705 slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", sharename);
2706 key.dptr = keystr;
2707 key.dsize = strlen(keystr);
2708 data = tdb_fetch(pdb->tdb, key);
2709 if (data.dptr) {
2710 if (data.dsize == sizeof(*status)) {
2711 /* this memcpy is ok since the status struct was
2712 not packed before storing it in the tdb */
2713 memcpy(status, data.dptr, sizeof(*status));
2714 }
2715 SAFE_FREE(data.dptr);
2716 }
2717
2718 /*
2719 * Now, fetch the print queue information. We first count the number
2720 * of entries, and then only retrieve the queue if necessary.
2721 */
2722
2723 if (!get_stored_queue_info(pdb, snum, &count, ppqueue)) {
2724 release_print_db(pdb);
2725 return 0;
2726 }
2727
2728 release_print_db(pdb);
2729 return count;
2730}
2731
2732/****************************************************************************
2733 Pause a queue.
2734****************************************************************************/
2735
2736BOOL print_queue_pause(struct current_user *user, int snum, WERROR *errcode)
2737{
2738 int ret;
2739 struct printif *current_printif = get_printer_fns( snum );
2740
2741 if (!print_access_check(user, snum, PRINTER_ACCESS_ADMINISTER)) {
2742 *errcode = WERR_ACCESS_DENIED;
2743 return False;
2744 }
2745
2746
2747 become_root();
2748
2749 ret = (*(current_printif->queue_pause))(snum);
2750
2751 unbecome_root();
2752
2753 if (ret != 0) {
2754 *errcode = WERR_INVALID_PARAM;
2755 return False;
2756 }
2757
2758 /* force update the database */
2759 print_cache_flush(lp_const_servicename(snum));
2760
2761 /* Send a printer notify message */
2762
2763 notify_printer_status(snum, PRINTER_STATUS_PAUSED);
2764
2765 return True;
2766}
2767
2768/****************************************************************************
2769 Resume a queue.
2770****************************************************************************/
2771
2772BOOL print_queue_resume(struct current_user *user, int snum, WERROR *errcode)
2773{
2774 int ret;
2775 struct printif *current_printif = get_printer_fns( snum );
2776
2777 if (!print_access_check(user, snum, PRINTER_ACCESS_ADMINISTER)) {
2778 *errcode = WERR_ACCESS_DENIED;
2779 return False;
2780 }
2781
2782 become_root();
2783
2784 ret = (*(current_printif->queue_resume))(snum);
2785
2786 unbecome_root();
2787
2788 if (ret != 0) {
2789 *errcode = WERR_INVALID_PARAM;
2790 return False;
2791 }
2792
2793 /* make sure the database is up to date */
2794 if (print_cache_expired(lp_const_servicename(snum), True))
2795 print_queue_update(snum, True);
2796
2797 /* Send a printer notify message */
2798
2799 notify_printer_status(snum, PRINTER_STATUS_OK);
2800
2801 return True;
2802}
2803
2804/****************************************************************************
2805 Purge a queue - implemented by deleting all jobs that we can delete.
2806****************************************************************************/
2807
2808BOOL print_queue_purge(struct current_user *user, int snum, WERROR *errcode)
2809{
2810 print_queue_struct *queue;
2811 print_status_struct status;
2812 int njobs, i;
2813 BOOL can_job_admin;
2814
2815 /* Force and update so the count is accurate (i.e. not a cached count) */
2816 print_queue_update(snum, True);
2817
2818 can_job_admin = print_access_check(user, snum, JOB_ACCESS_ADMINISTER);
2819 njobs = print_queue_status(snum, &queue, &status);
2820
2821 if ( can_job_admin )
2822 become_root();
2823
2824 for (i=0;i<njobs;i++) {
2825 BOOL owner = is_owner(user, lp_const_servicename(snum), queue[i].job);
2826
2827 if (owner || can_job_admin) {
2828 print_job_delete1(snum, queue[i].job);
2829 }
2830 }
2831
2832 if ( can_job_admin )
2833 unbecome_root();
2834
2835 /* update the cache */
2836 print_queue_update( snum, True );
2837
2838 SAFE_FREE(queue);
2839
2840 return True;
2841}
Note: See TracBrowser for help on using the repository browser.