2 Unix SMB/Netbios implementation.
4 printing backend routines
5 Copyright (C) Andrew Tridgell 1992-2000
6 Copyright (C) Jeremy Allison 2002
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.
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.
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.
26 extern SIG_ATOMIC_T got_sig_term
;
27 extern SIG_ATOMIC_T reload_after_sighup
;
29 /* Current printer interface */
30 static BOOL
remove_from_jobs_changed(const char* sharename
, uint32 jobid
);
33 the printing backend revolves around a tdb database that stores the
34 SMB view of the print queue
36 The key for this database is a jobid - a internally generated number that
37 uniquely identifies a print job
39 reading the print queue involves two steps:
40 - possibly running lpq and updating the internal database from that
41 - reading entries from the database
43 jobids are assigned when a job starts spooling.
46 static TDB_CONTEXT
*rap_tdb
;
47 static uint16 next_rap_jobid
;
48 struct rap_jobid_key
{
53 /***************************************************************************
54 Nightmare. LANMAN jobid's are 16 bit numbers..... We must map them to 32
55 bit RPC jobids.... JRA.
56 ***************************************************************************/
58 uint16
pjobid_to_rap(const char* sharename
, uint32 jobid
)
62 struct rap_jobid_key jinfo
;
65 DEBUG(10,("pjobid_to_rap: called.\n"));
68 /* Create the in-memory tdb. */
69 rap_tdb
= tdb_open_log(NULL
, 0, TDB_INTERNAL
, (O_RDWR
|O_CREAT
), 0644);
75 fstrcpy( jinfo
.sharename
, sharename
);
77 key
.dptr
= (char*)&jinfo
;
78 key
.dsize
= sizeof(jinfo
);
80 data
= tdb_fetch(rap_tdb
, key
);
81 if (data
.dptr
&& data
.dsize
== sizeof(uint16
)) {
82 rap_jobid
= SVAL(data
.dptr
, 0);
84 DEBUG(10,("pjobid_to_rap: jobid %u maps to RAP jobid %u\n",
85 (unsigned int)jobid
, (unsigned int)rap_jobid
));
89 /* Not found - create and store mapping. */
90 rap_jobid
= ++next_rap_jobid
;
92 rap_jobid
= ++next_rap_jobid
;
93 SSVAL(buf
,0,rap_jobid
);
94 data
.dptr
= (char*)buf
;
95 data
.dsize
= sizeof(rap_jobid
);
96 tdb_store(rap_tdb
, key
, data
, TDB_REPLACE
);
97 tdb_store(rap_tdb
, data
, key
, TDB_REPLACE
);
99 DEBUG(10,("pjobid_to_rap: created jobid %u maps to RAP jobid %u\n",
100 (unsigned int)jobid
, (unsigned int)rap_jobid
));
104 BOOL
rap_to_pjobid(uint16 rap_jobid
, fstring sharename
, uint32
*pjobid
)
109 DEBUG(10,("rap_to_pjobid called.\n"));
114 SSVAL(buf
,0,rap_jobid
);
115 key
.dptr
= (char*)buf
;
116 key
.dsize
= sizeof(rap_jobid
);
117 data
= tdb_fetch(rap_tdb
, key
);
118 if ( data
.dptr
&& data
.dsize
== sizeof(struct rap_jobid_key
) )
120 struct rap_jobid_key
*jinfo
= (struct rap_jobid_key
*)data
.dptr
;
121 fstrcpy( sharename
, jinfo
->sharename
);
122 *pjobid
= jinfo
->jobid
;
123 DEBUG(10,("rap_to_pjobid: jobid %u maps to RAP jobid %u\n",
124 (unsigned int)*pjobid
, (unsigned int)rap_jobid
));
125 SAFE_FREE(data
.dptr
);
129 DEBUG(10,("rap_to_pjobid: Failed to lookup RAP jobid %u\n",
130 (unsigned int)rap_jobid
));
131 SAFE_FREE(data
.dptr
);
135 static void rap_jobid_delete(const char* sharename
, uint32 jobid
)
139 struct rap_jobid_key jinfo
;
142 DEBUG(10,("rap_jobid_delete: called.\n"));
147 ZERO_STRUCT( jinfo
);
148 fstrcpy( jinfo
.sharename
, sharename
);
150 key
.dptr
= (char*)&jinfo
;
151 key
.dsize
= sizeof(jinfo
);
153 data
= tdb_fetch(rap_tdb
, key
);
154 if (!data
.dptr
|| (data
.dsize
!= sizeof(uint16
))) {
155 DEBUG(10,("rap_jobid_delete: cannot find jobid %u\n",
156 (unsigned int)jobid
));
157 SAFE_FREE(data
.dptr
);
161 DEBUG(10,("rap_jobid_delete: deleting jobid %u\n",
162 (unsigned int)jobid
));
164 rap_jobid
= SVAL(data
.dptr
, 0);
165 SAFE_FREE(data
.dptr
);
166 SSVAL(buf
,0,rap_jobid
);
167 data
.dptr
= (char*)buf
;
168 data
.dsize
= sizeof(rap_jobid
);
169 tdb_delete(rap_tdb
, key
);
170 tdb_delete(rap_tdb
, data
);
173 static int get_queue_status(const char* sharename
, print_status_struct
*);
175 /****************************************************************************
176 Initialise the printing backend. Called once at startup before the fork().
177 ****************************************************************************/
179 BOOL
print_backend_init(void)
181 const char *sversion
= "INFO/version";
182 pstring printing_path
;
183 int services
= lp_numservices();
186 unlink(lock_path("printing.tdb"));
187 pstrcpy(printing_path
,lock_path("printing"));
188 mkdir(printing_path
,0755);
190 /* handle a Samba upgrade */
192 for (snum
= 0; snum
< services
; snum
++) {
193 struct tdb_print_db
*pdb
;
194 if (!lp_print_ok(snum
))
197 pdb
= get_print_db_byname(lp_const_servicename(snum
));
200 if (tdb_lock_bystring(pdb
->tdb
, sversion
, 0) == -1) {
201 DEBUG(0,("print_backend_init: Failed to open printer %s database\n", lp_const_servicename(snum
) ));
202 release_print_db(pdb
);
205 if (tdb_fetch_int32(pdb
->tdb
, sversion
) != PRINT_DATABASE_VERSION
) {
206 tdb_traverse(pdb
->tdb
, tdb_traverse_delete_fn
, NULL
);
207 tdb_store_int32(pdb
->tdb
, sversion
, PRINT_DATABASE_VERSION
);
209 tdb_unlock_bystring(pdb
->tdb
, sversion
);
210 release_print_db(pdb
);
213 close_all_print_db(); /* Don't leave any open. */
215 /* do NT print initialization... */
216 return nt_printing_init();
219 /****************************************************************************
220 Shut down printing backend. Called once at shutdown to close the tdb.
221 ****************************************************************************/
223 void printing_end(void)
225 close_all_print_db(); /* Don't leave any open. */
228 /****************************************************************************
229 Retrieve the set of printing functions for a given service. This allows
230 us to set the printer function table based on the value of the 'printing'
233 Use the generic interface as the default and only use cups interface only
234 when asked for (and only when supported)
235 ****************************************************************************/
237 static struct printif
*get_printer_fns_from_type( int type
)
239 struct printif
*printer_fns
= &generic_printif
;
242 if ( type
== PRINT_CUPS
) {
243 printer_fns
= &cups_printif
;
245 #endif /* HAVE_CUPS */
248 if ( type
== PRINT_IPRINT
) {
249 printer_fns
= &iprint_printif
;
251 #endif /* HAVE_IPRINT */
253 printer_fns
->type
= type
;
258 static struct printif
*get_printer_fns( int snum
)
260 return get_printer_fns_from_type( lp_printing(snum
) );
264 /****************************************************************************
265 Useful function to generate a tdb key.
266 ****************************************************************************/
268 static TDB_DATA
print_key(uint32 jobid
)
274 ret
.dptr
= (void *)&j
;
275 ret
.dsize
= sizeof(j
);
279 /***********************************************************************
280 unpack a pjob from a tdb buffer
281 ***********************************************************************/
283 int unpack_pjob( char* buf
, int buflen
, struct printjob
*pjob
)
287 uint32 pjpid
, pjsysjob
, pjfd
, pjstarttime
, pjstatus
;
288 uint32 pjsize
, pjpage_count
, pjspooled
, pjsmbjob
;
293 len
+= tdb_unpack(buf
+len
, buflen
-len
, "dddddddddffff",
311 if ( (used
= unpack_devicemode(&pjob
->nt_devmode
, buf
+len
, buflen
-len
)) == -1 )
317 pjob
->sysjob
= pjsysjob
;
319 pjob
->starttime
= pjstarttime
;
320 pjob
->status
= pjstatus
;
322 pjob
->page_count
= pjpage_count
;
323 pjob
->spooled
= pjspooled
;
324 pjob
->smbjob
= pjsmbjob
;
330 /****************************************************************************
331 Useful function to find a print job in the database.
332 ****************************************************************************/
334 static struct printjob
*print_job_find(const char *sharename
, uint32 jobid
)
336 static struct printjob pjob
;
338 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
344 ret
= tdb_fetch(pdb
->tdb
, print_key(jobid
));
345 release_print_db(pdb
);
350 if ( pjob
.nt_devmode
)
351 free_nt_devicemode( &pjob
.nt_devmode
);
355 if ( unpack_pjob( ret
.dptr
, ret
.dsize
, &pjob
) == -1 ) {
364 /* Convert a unix jobid to a smb jobid */
366 static uint32 sysjob_to_jobid_value
;
368 static int unixjob_traverse_fn(TDB_CONTEXT
*the_tdb
, TDB_DATA key
,
369 TDB_DATA data
, void *state
)
371 struct printjob
*pjob
;
372 int *sysjob
= (int *)state
;
374 if (!data
.dptr
|| data
.dsize
== 0)
377 pjob
= (struct printjob
*)data
.dptr
;
378 if (key
.dsize
!= sizeof(uint32
))
381 if (*sysjob
== pjob
->sysjob
) {
382 uint32 jobid
= IVAL(key
.dptr
,0);
384 sysjob_to_jobid_value
= jobid
;
391 /****************************************************************************
392 This is a *horribly expensive call as we have to iterate through all the
393 current printer tdb's. Don't do this often ! JRA.
394 ****************************************************************************/
396 uint32
sysjob_to_jobid(int unix_jobid
)
398 int services
= lp_numservices();
401 sysjob_to_jobid_value
= (uint32
)-1;
403 for (snum
= 0; snum
< services
; snum
++) {
404 struct tdb_print_db
*pdb
;
405 if (!lp_print_ok(snum
))
407 pdb
= get_print_db_byname(lp_const_servicename(snum
));
411 tdb_traverse(pdb
->tdb
, unixjob_traverse_fn
, &unix_jobid
);
412 release_print_db(pdb
);
413 if (sysjob_to_jobid_value
!= (uint32
)-1)
414 return sysjob_to_jobid_value
;
419 /****************************************************************************
420 Send notifications based on what has changed after a pjob_store.
421 ****************************************************************************/
425 uint32 spoolss_status
;
426 } lpq_to_spoolss_status_map
[] = {
427 { LPQ_QUEUED
, JOB_STATUS_QUEUED
},
428 { LPQ_PAUSED
, JOB_STATUS_PAUSED
},
429 { LPQ_SPOOLING
, JOB_STATUS_SPOOLING
},
430 { LPQ_PRINTING
, JOB_STATUS_PRINTING
},
431 { LPQ_DELETING
, JOB_STATUS_DELETING
},
432 { LPQ_OFFLINE
, JOB_STATUS_OFFLINE
},
433 { LPQ_PAPEROUT
, JOB_STATUS_PAPEROUT
},
434 { LPQ_PRINTED
, JOB_STATUS_PRINTED
},
435 { LPQ_DELETED
, JOB_STATUS_DELETED
},
436 { LPQ_BLOCKED
, JOB_STATUS_BLOCKED
},
437 { LPQ_USER_INTERVENTION
, JOB_STATUS_USER_INTERVENTION
},
441 /* Convert a lpq status value stored in printing.tdb into the
442 appropriate win32 API constant. */
444 static uint32
map_to_spoolss_status(uint32 lpq_status
)
448 while (lpq_to_spoolss_status_map
[i
].lpq_status
!= -1) {
449 if (lpq_to_spoolss_status_map
[i
].lpq_status
== lpq_status
)
450 return lpq_to_spoolss_status_map
[i
].spoolss_status
;
457 static void pjob_store_notify(const char* sharename
, uint32 jobid
, struct printjob
*old_data
,
458 struct printjob
*new_data
)
460 BOOL new_job
= False
;
465 /* Job attributes that can't be changed. We only send
466 notification for these on a new job. */
468 /* ACHTUNG! Due to a bug in Samba's spoolss parsing of the
469 NOTIFY_INFO_DATA buffer, we *have* to send the job submission
470 time first or else we'll end up with potential alignment
471 errors. I don't think the systemtime should be spooled as
472 a string, but this gets us around that error.
473 --jerry (i'll feel dirty for this) */
476 notify_job_submitted(sharename
, jobid
, new_data
->starttime
);
477 notify_job_username(sharename
, jobid
, new_data
->user
);
480 if (new_job
|| !strequal(old_data
->jobname
, new_data
->jobname
))
481 notify_job_name(sharename
, jobid
, new_data
->jobname
);
483 /* Job attributes of a new job or attributes that can be
486 if (new_job
|| !strequal(old_data
->jobname
, new_data
->jobname
))
487 notify_job_name(sharename
, jobid
, new_data
->jobname
);
489 if (new_job
|| old_data
->status
!= new_data
->status
)
490 notify_job_status(sharename
, jobid
, map_to_spoolss_status(new_data
->status
));
492 if (new_job
|| old_data
->size
!= new_data
->size
)
493 notify_job_total_bytes(sharename
, jobid
, new_data
->size
);
495 if (new_job
|| old_data
->page_count
!= new_data
->page_count
)
496 notify_job_total_pages(sharename
, jobid
, new_data
->page_count
);
499 /****************************************************************************
500 Store a job structure back to the database.
501 ****************************************************************************/
503 static BOOL
pjob_store(const char* sharename
, uint32 jobid
, struct printjob
*pjob
)
505 TDB_DATA old_data
, new_data
;
507 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
509 int len
, newlen
, buflen
;
517 old_data
= tdb_fetch(pdb
->tdb
, print_key(jobid
));
519 /* Doh! Now we have to pack/unpack data since the NT_DEVICEMODE was added */
526 len
+= tdb_pack(buf
+len
, buflen
-len
, "dddddddddffff",
528 (uint32
)pjob
->sysjob
,
530 (uint32
)pjob
->starttime
,
531 (uint32
)pjob
->status
,
533 (uint32
)pjob
->page_count
,
534 (uint32
)pjob
->spooled
,
535 (uint32
)pjob
->smbjob
,
541 len
+= pack_devicemode(pjob
->nt_devmode
, buf
+len
, buflen
-len
);
544 buf
= (char *)SMB_REALLOC(buf
, len
);
546 DEBUG(0,("pjob_store: failed to enlarge buffer!\n"));
551 } while ( buflen
!= len
);
557 new_data
.dsize
= len
;
558 ret
= (tdb_store(pdb
->tdb
, print_key(jobid
), new_data
, TDB_REPLACE
) == 0);
560 release_print_db(pdb
);
562 /* Send notify updates for what has changed */
565 struct printjob old_pjob
;
567 if ( old_data
.dsize
)
569 if ( unpack_pjob( old_data
.dptr
, old_data
.dsize
, &old_pjob
) != -1 )
571 pjob_store_notify( sharename
, jobid
, &old_pjob
, pjob
);
572 free_nt_devicemode( &old_pjob
.nt_devmode
);
577 pjob_store_notify( sharename
, jobid
, NULL
, pjob
);
582 SAFE_FREE( old_data
.dptr
);
588 /****************************************************************************
589 Remove a job structure from the database.
590 ****************************************************************************/
592 void pjob_delete(const char* sharename
, uint32 jobid
)
594 struct printjob
*pjob
;
595 uint32 job_status
= 0;
596 struct tdb_print_db
*pdb
;
598 pdb
= get_print_db_byname( sharename
);
603 pjob
= print_job_find( sharename
, jobid
);
606 DEBUG(5, ("pjob_delete: we were asked to delete nonexistent job %u\n",
607 (unsigned int)jobid
));
608 release_print_db(pdb
);
612 /* We must cycle through JOB_STATUS_DELETING and
613 JOB_STATUS_DELETED for the port monitor to delete the job
616 job_status
= JOB_STATUS_DELETING
|JOB_STATUS_DELETED
;
617 notify_job_status(sharename
, jobid
, job_status
);
619 /* Remove from printing.tdb */
621 tdb_delete(pdb
->tdb
, print_key(jobid
));
622 remove_from_jobs_changed(sharename
, jobid
);
623 release_print_db( pdb
);
624 rap_jobid_delete(sharename
, jobid
);
627 /****************************************************************************
628 Parse a file name from the system spooler to generate a jobid.
629 ****************************************************************************/
631 static uint32
print_parse_jobid(char *fname
)
635 if (strncmp(fname
,PRINT_SPOOL_PREFIX
,strlen(PRINT_SPOOL_PREFIX
)) != 0)
637 fname
+= strlen(PRINT_SPOOL_PREFIX
);
643 return (uint32
)jobid
;
646 /****************************************************************************
647 List a unix job in the print database.
648 ****************************************************************************/
650 static void print_unix_job(const char *sharename
, print_queue_struct
*q
, uint32 jobid
)
652 struct printjob pj
, *old_pj
;
654 if (jobid
== (uint32
)-1)
655 jobid
= q
->job
+ UNIX_JOB_START
;
657 /* Preserve the timestamp on an existing unix print job */
659 old_pj
= print_job_find(sharename
, jobid
);
666 pj
.starttime
= old_pj
? old_pj
->starttime
: q
->time
;
667 pj
.status
= q
->status
;
670 fstrcpy(pj
.filename
, old_pj
? old_pj
->filename
: "");
671 if (jobid
< UNIX_JOB_START
) {
673 fstrcpy(pj
.jobname
, old_pj
? old_pj
->jobname
: "Remote Downlevel Document");
676 fstrcpy(pj
.jobname
, old_pj
? old_pj
->jobname
: q
->fs_file
);
678 fstrcpy(pj
.user
, old_pj
? old_pj
->user
: q
->fs_user
);
679 fstrcpy(pj
.queuename
, old_pj
? old_pj
->queuename
: sharename
);
681 pjob_store(sharename
, jobid
, &pj
);
685 struct traverse_struct
{
686 print_queue_struct
*queue
;
687 int qcount
, snum
, maxcount
, total_jobs
;
688 const char *sharename
;
690 const char *lprm_command
;
691 struct printif
*print_if
;
694 /****************************************************************************
695 Utility fn to delete any jobs that are no longer active.
696 ****************************************************************************/
698 static int traverse_fn_delete(TDB_CONTEXT
*t
, TDB_DATA key
, TDB_DATA data
, void *state
)
700 struct traverse_struct
*ts
= (struct traverse_struct
*)state
;
701 struct printjob pjob
;
705 if ( key
.dsize
!= sizeof(jobid
) )
708 jobid
= IVAL(key
.dptr
, 0);
709 if ( unpack_pjob( data
.dptr
, data
.dsize
, &pjob
) == -1 )
711 free_nt_devicemode( &pjob
.nt_devmode
);
715 /* remove a unix job if it isn't in the system queue any more */
717 for (i
=0;i
<ts
->qcount
;i
++) {
718 uint32 u_jobid
= (ts
->queue
[i
].job
+ UNIX_JOB_START
);
719 if (jobid
== u_jobid
)
722 if (i
== ts
->qcount
) {
723 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !smbjob\n",
724 (unsigned int)jobid
));
725 pjob_delete(ts
->sharename
, jobid
);
729 /* need to continue the the bottom of the function to
730 save the correct attributes */
733 /* maybe it hasn't been spooled yet */
735 /* if a job is not spooled and the process doesn't
736 exist then kill it. This cleans up after smbd
738 if (!process_exists_by_pid(pjob
.pid
)) {
739 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !process_exists (%u)\n",
740 (unsigned int)jobid
, (unsigned int)pjob
.pid
));
741 pjob_delete(ts
->sharename
, jobid
);
747 /* this check only makes sense for jobs submitted from Windows clients */
750 for (i
=0;i
<ts
->qcount
;i
++) {
753 if ( pjob
.status
== LPQ_DELETED
)
756 curr_jobid
= print_parse_jobid(ts
->queue
[i
].fs_file
);
758 if (jobid
== curr_jobid
) {
760 /* try to clean up any jobs that need to be deleted */
762 if ( pjob
.status
== LPQ_DELETING
) {
765 result
= (*(ts
->print_if
->job_delete
))(
766 ts
->sharename
, ts
->lprm_command
, &pjob
);
769 /* if we can't delete, then reset the job status */
770 pjob
.status
= LPQ_QUEUED
;
771 pjob_store(ts
->sharename
, jobid
, &pjob
);
774 /* if we deleted the job, the remove the tdb record */
775 pjob_delete(ts
->sharename
, jobid
);
776 pjob
.status
= LPQ_DELETED
;
786 /* The job isn't in the system queue - we have to assume it has
787 completed, so delete the database entry. */
789 if (i
== ts
->qcount
) {
791 /* A race can occur between the time a job is spooled and
792 when it appears in the lpq output. This happens when
793 the job is added to printing.tdb when another smbd
794 running print_queue_update() has completed a lpq and
795 is currently traversing the printing tdb and deleting jobs.
796 Don't delete the job if it was submitted after the lpq_time. */
798 if (pjob
.starttime
< ts
->lpq_time
) {
799 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to pjob.starttime (%u) < ts->lpq_time (%u)\n",
801 (unsigned int)pjob
.starttime
,
802 (unsigned int)ts
->lpq_time
));
803 pjob_delete(ts
->sharename
, jobid
);
809 /* Save the pjob attributes we will store.
810 FIXME!!! This is the only place where queue->job
811 represents the SMB jobid --jerry */
813 ts
->queue
[i
].job
= jobid
;
814 ts
->queue
[i
].size
= pjob
.size
;
815 ts
->queue
[i
].page_count
= pjob
.page_count
;
816 ts
->queue
[i
].status
= pjob
.status
;
817 ts
->queue
[i
].priority
= 1;
818 ts
->queue
[i
].time
= pjob
.starttime
;
819 fstrcpy(ts
->queue
[i
].fs_user
, pjob
.user
);
820 fstrcpy(ts
->queue
[i
].fs_file
, pjob
.jobname
);
827 /****************************************************************************
828 Check if the print queue has been updated recently enough.
829 ****************************************************************************/
831 static void print_cache_flush(int snum
)
834 const char *sharename
= lp_const_servicename(snum
);
835 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
839 slprintf(key
, sizeof(key
)-1, "CACHE/%s", sharename
);
840 tdb_store_int32(pdb
->tdb
, key
, -1);
841 release_print_db(pdb
);
844 /****************************************************************************
845 Check if someone already thinks they are doing the update.
846 ****************************************************************************/
848 static pid_t
get_updating_pid(const char *sharename
)
853 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
857 slprintf(keystr
, sizeof(keystr
)-1, "UPDATING/%s", sharename
);
859 key
.dsize
= strlen(keystr
);
861 data
= tdb_fetch(pdb
->tdb
, key
);
862 release_print_db(pdb
);
863 if (!data
.dptr
|| data
.dsize
!= sizeof(pid_t
)) {
864 SAFE_FREE(data
.dptr
);
868 updating_pid
= IVAL(data
.dptr
, 0);
869 SAFE_FREE(data
.dptr
);
871 if (process_exists_by_pid(updating_pid
))
877 /****************************************************************************
878 Set the fact that we're doing the update, or have finished doing the update
880 ****************************************************************************/
882 static void set_updating_pid(const fstring sharename
, BOOL updating
)
887 pid_t updating_pid
= sys_getpid();
890 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
895 slprintf(keystr
, sizeof(keystr
)-1, "UPDATING/%s", sharename
);
897 key
.dsize
= strlen(keystr
);
899 DEBUG(5, ("set_updating_pid: %s updating lpq cache for print share %s\n",
900 updating
? "" : "not ",
904 tdb_delete(pdb
->tdb
, key
);
905 release_print_db(pdb
);
909 SIVAL( buffer
, 0, updating_pid
);
910 data
.dptr
= (void *)buffer
;
911 data
.dsize
= 4; /* we always assume this is a 4 byte value */
913 tdb_store(pdb
->tdb
, key
, data
, TDB_REPLACE
);
914 release_print_db(pdb
);
917 /****************************************************************************
918 Sort print jobs by submittal time.
919 ****************************************************************************/
921 static int printjob_comp(print_queue_struct
*j1
, print_queue_struct
*j2
)
932 /* Sort on job start time */
934 if (j1
->time
== j2
->time
)
936 return (j1
->time
> j2
->time
) ? 1 : -1;
939 /****************************************************************************
940 Store the sorted queue representation for later portmon retrieval.
942 ****************************************************************************/
944 static void store_queue_struct(struct tdb_print_db
*pdb
, struct traverse_struct
*pts
)
947 int max_reported_jobs
= lp_max_reported_jobs(pts
->snum
);
948 print_queue_struct
*queue
= pts
->queue
;
953 if (max_reported_jobs
&& (max_reported_jobs
< pts
->qcount
))
954 pts
->qcount
= max_reported_jobs
;
957 /* Work out the size. */
959 data
.dsize
+= tdb_pack(NULL
, 0, "d", qcount
);
961 for (i
= 0; i
< pts
->qcount
; i
++) {
962 if ( queue
[i
].status
== LPQ_DELETED
)
966 data
.dsize
+= tdb_pack(NULL
, 0, "ddddddff",
967 (uint32
)queue
[i
].job
,
968 (uint32
)queue
[i
].size
,
969 (uint32
)queue
[i
].page_count
,
970 (uint32
)queue
[i
].status
,
971 (uint32
)queue
[i
].priority
,
972 (uint32
)queue
[i
].time
,
977 if ((data
.dptr
= SMB_MALLOC(data
.dsize
)) == NULL
)
981 len
+= tdb_pack(data
.dptr
+ len
, data
.dsize
- len
, "d", qcount
);
982 for (i
= 0; i
< pts
->qcount
; i
++) {
983 if ( queue
[i
].status
== LPQ_DELETED
)
986 len
+= tdb_pack(data
.dptr
+ len
, data
.dsize
- len
, "ddddddff",
987 (uint32
)queue
[i
].job
,
988 (uint32
)queue
[i
].size
,
989 (uint32
)queue
[i
].page_count
,
990 (uint32
)queue
[i
].status
,
991 (uint32
)queue
[i
].priority
,
992 (uint32
)queue
[i
].time
,
997 tdb_store(pdb
->tdb
, string_tdb_data("INFO/linear_queue_array"), data
,
999 SAFE_FREE(data
.dptr
);
1003 static TDB_DATA
get_jobs_changed_data(struct tdb_print_db
*pdb
)
1009 data
= tdb_fetch(pdb
->tdb
, string_tdb_data("INFO/jobs_changed"));
1010 if (data
.dptr
== NULL
|| data
.dsize
== 0 || (data
.dsize
% 4 != 0)) {
1011 SAFE_FREE(data
.dptr
);
1018 static void check_job_changed(const char *sharename
, TDB_DATA data
, uint32 jobid
)
1021 unsigned int job_count
= data
.dsize
/ 4;
1023 for (i
= 0; i
< job_count
; i
++) {
1026 ch_jobid
= IVAL(data
.dptr
, i
*4);
1027 if (ch_jobid
== jobid
)
1028 remove_from_jobs_changed(sharename
, jobid
);
1032 /****************************************************************************
1033 Check if the print queue has been updated recently enough.
1034 ****************************************************************************/
1036 static BOOL
print_cache_expired(const char *sharename
, BOOL check_pending
)
1039 time_t last_qscan_time
, time_now
= time(NULL
);
1040 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1041 BOOL result
= False
;
1046 snprintf(key
, sizeof(key
), "CACHE/%s", sharename
);
1047 last_qscan_time
= (time_t)tdb_fetch_int32(pdb
->tdb
, key
);
1050 * Invalidate the queue for 3 reasons.
1051 * (1). last queue scan time == -1.
1052 * (2). Current time - last queue scan time > allowed cache time.
1053 * (3). last queue scan time > current time + MAX_CACHE_VALID_TIME (1 hour by default).
1054 * This last test picks up machines for which the clock has been moved
1055 * forward, an lpq scan done and then the clock moved back. Otherwise
1056 * that last lpq scan would stay around for a loooong loooong time... :-). JRA.
1059 if (last_qscan_time
== ((time_t)-1)
1060 || (time_now
- last_qscan_time
) >= lp_lpqcachetime()
1061 || last_qscan_time
> (time_now
+ MAX_CACHE_VALID_TIME
))
1064 time_t msg_pending_time
;
1066 DEBUG(4, ("print_cache_expired: cache expired for queue %s "
1067 "(last_qscan_time = %d, time now = %d, qcachetime = %d)\n",
1068 sharename
, (int)last_qscan_time
, (int)time_now
,
1069 (int)lp_lpqcachetime() ));
1071 /* check if another smbd has already sent a message to update the
1072 queue. Give the pending message one minute to clear and
1073 then send another message anyways. Make sure to check for
1074 clocks that have been run forward and then back again. */
1076 snprintf(key
, sizeof(key
), "MSG_PENDING/%s", sharename
);
1079 && tdb_fetch_uint32( pdb
->tdb
, key
, &u
)
1080 && (msg_pending_time
=u
) > 0
1081 && msg_pending_time
<= time_now
1082 && (time_now
- msg_pending_time
) < 60 )
1084 DEBUG(4,("print_cache_expired: message already pending for %s. Accepting cache\n",
1093 release_print_db(pdb
);
1097 /****************************************************************************
1098 main work for updating the lpq cahe for a printer queue
1099 ****************************************************************************/
1101 static void print_queue_update_internal( const char *sharename
,
1102 struct printif
*current_printif
,
1103 char *lpq_command
, char *lprm_command
)
1106 print_queue_struct
*queue
= NULL
;
1107 print_status_struct status
;
1108 print_status_struct old_status
;
1109 struct printjob
*pjob
;
1110 struct traverse_struct tstruct
;
1113 fstring keystr
, cachestr
;
1114 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1120 DEBUG(5,("print_queue_update_internal: printer = %s, type = %d, lpq command = [%s]\n",
1121 sharename
, current_printif
->type
, lpq_command
));
1124 * Update the cache time FIRST ! Stops others even
1125 * attempting to get the lock and doing this
1126 * if the lpq takes a long time.
1129 slprintf(cachestr
, sizeof(cachestr
)-1, "CACHE/%s", sharename
);
1130 tdb_store_int32(pdb
->tdb
, cachestr
, (int)time(NULL
));
1132 /* get the current queue using the appropriate interface */
1133 ZERO_STRUCT(status
);
1135 qcount
= (*(current_printif
->queue_get
))(sharename
,
1136 current_printif
->type
,
1137 lpq_command
, &queue
, &status
);
1139 DEBUG(3, ("print_queue_update_internal: %d job%s in queue for %s\n",
1140 qcount
, (qcount
!= 1) ? "s" : "", sharename
));
1142 /* Sort the queue by submission time otherwise they are displayed
1145 qsort(queue
, qcount
, sizeof(print_queue_struct
),
1146 QSORT_CAST(printjob_comp
));
1149 any job in the internal database that is marked as spooled
1150 and doesn't exist in the system queue is considered finished
1151 and removed from the database
1153 any job in the system database but not in the internal database
1154 is added as a unix job
1156 fill in any system job numbers as we go
1159 jcdata
= get_jobs_changed_data(pdb
);
1161 for (i
=0; i
<qcount
; i
++) {
1162 uint32 jobid
= print_parse_jobid(queue
[i
].fs_file
);
1164 if (jobid
== (uint32
)-1) {
1165 /* assume its a unix print job */
1166 print_unix_job(sharename
, &queue
[i
], jobid
);
1170 /* we have an active SMB print job - update its status */
1171 pjob
= print_job_find(sharename
, jobid
);
1173 /* err, somethings wrong. Probably smbd was restarted
1174 with jobs in the queue. All we can do is treat them
1175 like unix jobs. Pity. */
1176 print_unix_job(sharename
, &queue
[i
], jobid
);
1180 pjob
->sysjob
= queue
[i
].job
;
1182 /* don't reset the status on jobs to be deleted */
1184 if ( pjob
->status
!= LPQ_DELETING
)
1185 pjob
->status
= queue
[i
].status
;
1187 pjob_store(sharename
, jobid
, pjob
);
1189 check_job_changed(sharename
, jcdata
, jobid
);
1192 SAFE_FREE(jcdata
.dptr
);
1194 /* now delete any queued entries that don't appear in the
1196 tstruct
.queue
= queue
;
1197 tstruct
.qcount
= qcount
;
1199 tstruct
.total_jobs
= 0;
1200 tstruct
.lpq_time
= time(NULL
);
1201 tstruct
.sharename
= sharename
;
1202 tstruct
.lprm_command
= lprm_command
;
1203 tstruct
.print_if
= current_printif
;
1205 tdb_traverse(pdb
->tdb
, traverse_fn_delete
, (void *)&tstruct
);
1207 /* Store the linearised queue, max jobs only. */
1208 store_queue_struct(pdb
, &tstruct
);
1210 SAFE_FREE(tstruct
.queue
);
1212 DEBUG(10,("print_queue_update_internal: printer %s INFO/total_jobs = %d\n",
1213 sharename
, tstruct
.total_jobs
));
1215 tdb_store_int32(pdb
->tdb
, "INFO/total_jobs", tstruct
.total_jobs
);
1217 get_queue_status(sharename
, &old_status
);
1218 if (old_status
.qcount
!= qcount
)
1219 DEBUG(10,("print_queue_update_internal: queue status change %d jobs -> %d jobs for printer %s\n",
1220 old_status
.qcount
, qcount
, sharename
));
1222 /* store the new queue status structure */
1223 slprintf(keystr
, sizeof(keystr
)-1, "STATUS/%s", sharename
);
1225 key
.dsize
= strlen(keystr
);
1227 status
.qcount
= qcount
;
1228 data
.dptr
= (void *)&status
;
1229 data
.dsize
= sizeof(status
);
1230 tdb_store(pdb
->tdb
, key
, data
, TDB_REPLACE
);
1233 * Update the cache time again. We want to do this call
1234 * as little as possible...
1237 slprintf(keystr
, sizeof(keystr
)-1, "CACHE/%s", sharename
);
1238 tdb_store_int32(pdb
->tdb
, keystr
, (int32
)time(NULL
));
1240 /* clear the msg pending record for this queue */
1242 snprintf(keystr
, sizeof(keystr
), "MSG_PENDING/%s", sharename
);
1244 if ( !tdb_store_uint32( pdb
->tdb
, keystr
, 0 ) ) {
1245 /* log a message but continue on */
1247 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1251 release_print_db( pdb
);
1256 /****************************************************************************
1257 Update the internal database from the system print queue for a queue.
1258 obtain a lock on the print queue before proceeding (needed when mutiple
1259 smbd processes maytry to update the lpq cache concurrently).
1260 ****************************************************************************/
1262 static void print_queue_update_with_lock( const char *sharename
,
1263 struct printif
*current_printif
,
1264 char *lpq_command
, char *lprm_command
)
1267 struct tdb_print_db
*pdb
;
1269 DEBUG(5,("print_queue_update_with_lock: printer share = %s\n", sharename
));
1270 pdb
= get_print_db_byname(sharename
);
1274 if ( !print_cache_expired(sharename
, False
) ) {
1275 DEBUG(5,("print_queue_update_with_lock: print cache for %s is still ok\n", sharename
));
1276 release_print_db(pdb
);
1281 * Check to see if someone else is doing this update.
1282 * This is essentially a mutex on the update.
1285 if (get_updating_pid(sharename
) != -1) {
1286 release_print_db(pdb
);
1290 /* Lock the queue for the database update */
1292 slprintf(keystr
, sizeof(keystr
) - 1, "LOCK/%s", sharename
);
1293 /* Only wait 10 seconds for this. */
1294 if (tdb_lock_bystring(pdb
->tdb
, keystr
, 10) == -1) {
1295 DEBUG(0,("print_queue_update_with_lock: Failed to lock printer %s database\n", sharename
));
1296 release_print_db(pdb
);
1301 * Ensure that no one else got in here.
1302 * If the updating pid is still -1 then we are
1306 if (get_updating_pid(sharename
) != -1) {
1308 * Someone else is doing the update, exit.
1310 tdb_unlock_bystring(pdb
->tdb
, keystr
);
1311 release_print_db(pdb
);
1316 * We're going to do the update ourselves.
1319 /* Tell others we're doing the update. */
1320 set_updating_pid(sharename
, True
);
1323 * Allow others to enter and notice we're doing
1327 tdb_unlock_bystring(pdb
->tdb
, keystr
);
1329 /* do the main work now */
1331 print_queue_update_internal( sharename
, current_printif
,
1332 lpq_command
, lprm_command
);
1334 /* Delete our pid from the db. */
1335 set_updating_pid(sharename
, False
);
1336 release_print_db(pdb
);
1339 /****************************************************************************
1340 this is the receive function of the background lpq updater
1341 ****************************************************************************/
1342 static void print_queue_receive(int msg_type
, struct process_id src
,
1343 void *buf
, size_t msglen
)
1346 pstring lpqcommand
, lprmcommand
;
1350 len
= tdb_unpack( buf
, msglen
, "fdPP",
1357 DEBUG(0,("print_queue_receive: Got invalid print queue update message\n"));
1361 print_queue_update_with_lock(sharename
,
1362 get_printer_fns_from_type(printing_type
),
1363 lpqcommand
, lprmcommand
);
1368 static pid_t background_lpq_updater_pid
= -1;
1370 /****************************************************************************
1371 main thread of the background lpq updater
1372 ****************************************************************************/
1373 void start_background_queue(void)
1375 DEBUG(3,("start_background_queue: Starting background LPQ thread\n"));
1376 background_lpq_updater_pid
= sys_fork();
1378 if (background_lpq_updater_pid
== -1) {
1379 DEBUG(5,("start_background_queue: background LPQ thread failed to start. %s\n", strerror(errno
) ));
1383 if(background_lpq_updater_pid
== 0) {
1385 DEBUG(5,("start_background_queue: background LPQ thread started\n"));
1387 claim_connection( NULL
, "smbd lpq backend", 0, False
,
1388 FLAG_MSG_GENERAL
|FLAG_MSG_SMBD
|FLAG_MSG_PRINT_GENERAL
);
1390 if (!locking_init(0)) {
1394 message_register(MSG_PRINTER_UPDATE
, print_queue_receive
);
1396 DEBUG(5,("start_background_queue: background LPQ thread waiting for messages\n"));
1400 /* check for some essential signals first */
1403 exit_server("Caught TERM signal");
1406 if (reload_after_sighup
) {
1407 change_to_root_user();
1408 DEBUG(1,("Reloading services after SIGHUP\n"));
1409 reload_services(False
);
1410 reload_after_sighup
= 0;
1413 /* now check for messages */
1415 DEBUG(10,("start_background_queue: background LPQ thread got a message\n"));
1418 /* process any pending print change notify messages */
1420 print_notify_send_messages(0);
1425 /****************************************************************************
1426 update the internal database from the system print queue for a queue
1427 ****************************************************************************/
1429 static void print_queue_update(int snum
, BOOL force
)
1433 pstring lpqcommand
, lprmcommand
;
1434 char *buffer
= NULL
;
1437 struct tdb_print_db
*pdb
;
1439 struct printif
*current_printif
;
1441 fstrcpy( sharename
, lp_const_servicename(snum
));
1443 /* don't strip out characters like '$' from the printername */
1445 pstrcpy( lpqcommand
, lp_lpqcommand(snum
));
1446 string_sub2( lpqcommand
, "%p", PRINTERNAME(snum
), sizeof(lpqcommand
),
1447 False
, False
, False
);
1448 standard_sub_snum( snum
, lpqcommand
, sizeof(lpqcommand
) );
1450 pstrcpy( lprmcommand
, lp_lprmcommand(snum
));
1451 string_sub2( lprmcommand
, "%p", PRINTERNAME(snum
), sizeof(lprmcommand
),
1452 False
, False
, False
);
1453 standard_sub_snum( snum
, lprmcommand
, sizeof(lprmcommand
) );
1456 * Make sure that the background queue process exists.
1457 * Otherwise just do the update ourselves
1460 if ( force
|| background_lpq_updater_pid
== -1 ) {
1461 DEBUG(4,("print_queue_update: updating queue [%s] myself\n", sharename
));
1462 current_printif
= get_printer_fns( snum
);
1463 print_queue_update_with_lock( sharename
, current_printif
, lpqcommand
, lprmcommand
);
1468 type
= lp_printing(snum
);
1470 /* get the length */
1472 len
= tdb_pack( buffer
, len
, "fdPP",
1478 buffer
= SMB_XMALLOC_ARRAY( char, len
);
1480 /* now pack the buffer */
1481 newlen
= tdb_pack( buffer
, len
, "fdPP",
1487 SMB_ASSERT( newlen
== len
);
1489 DEBUG(10,("print_queue_update: Sending message -> printer = %s, "
1490 "type = %d, lpq command = [%s] lprm command = [%s]\n",
1491 sharename
, type
, lpqcommand
, lprmcommand
));
1493 /* here we set a msg pending record for other smbd processes
1494 to throttle the number of duplicate print_queue_update msgs
1497 pdb
= get_print_db_byname(sharename
);
1503 snprintf(key
, sizeof(key
), "MSG_PENDING/%s", sharename
);
1505 if ( !tdb_store_uint32( pdb
->tdb
, key
, time(NULL
) ) ) {
1506 /* log a message but continue on */
1508 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1512 release_print_db( pdb
);
1514 /* finally send the message */
1517 message_send_pid(pid_to_procid(background_lpq_updater_pid
),
1518 MSG_PRINTER_UPDATE
, buffer
, len
, False
);
1521 SAFE_FREE( buffer
);
1526 /****************************************************************************
1527 Create/Update an entry in the print tdb that will allow us to send notify
1528 updates only to interested smbd's.
1529 ****************************************************************************/
1531 BOOL
print_notify_register_pid(int snum
)
1534 struct tdb_print_db
*pdb
= NULL
;
1535 TDB_CONTEXT
*tdb
= NULL
;
1536 const char *printername
;
1537 uint32 mypid
= (uint32
)sys_getpid();
1541 /* if (snum == -1), then the change notify request was
1542 on a print server handle and we need to register on
1547 int num_services
= lp_numservices();
1550 for ( idx
=0; idx
<num_services
; idx
++ ) {
1551 if (lp_snum_ok(idx
) && lp_print_ok(idx
) )
1552 print_notify_register_pid(idx
);
1557 else /* register for a specific printer */
1559 printername
= lp_const_servicename(snum
);
1560 pdb
= get_print_db_byname(printername
);
1566 if (tdb_lock_bystring(tdb
, NOTIFY_PID_LIST_KEY
, 10) == -1) {
1567 DEBUG(0,("print_notify_register_pid: Failed to lock printer %s\n",
1570 release_print_db(pdb
);
1574 data
= get_printer_notify_pid_list( tdb
, printername
, True
);
1576 /* Add ourselves and increase the refcount. */
1578 for (i
= 0; i
< data
.dsize
; i
+= 8) {
1579 if (IVAL(data
.dptr
,i
) == mypid
) {
1580 uint32 new_refcount
= IVAL(data
.dptr
, i
+4) + 1;
1581 SIVAL(data
.dptr
, i
+4, new_refcount
);
1586 if (i
== data
.dsize
) {
1587 /* We weren't in the list. Realloc. */
1588 data
.dptr
= SMB_REALLOC(data
.dptr
, data
.dsize
+ 8);
1590 DEBUG(0,("print_notify_register_pid: Relloc fail for printer %s\n",
1595 SIVAL(data
.dptr
,data
.dsize
- 8,mypid
);
1596 SIVAL(data
.dptr
,data
.dsize
- 4,1); /* Refcount. */
1599 /* Store back the record. */
1600 if (tdb_store_bystring(tdb
, NOTIFY_PID_LIST_KEY
, data
, TDB_REPLACE
) == -1) {
1601 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1602 list for printer %s\n", printername
));
1610 tdb_unlock_bystring(tdb
, NOTIFY_PID_LIST_KEY
);
1612 release_print_db(pdb
);
1613 SAFE_FREE(data
.dptr
);
1617 /****************************************************************************
1618 Update an entry in the print tdb that will allow us to send notify
1619 updates only to interested smbd's.
1620 ****************************************************************************/
1622 BOOL
print_notify_deregister_pid(int snum
)
1625 struct tdb_print_db
*pdb
= NULL
;
1626 TDB_CONTEXT
*tdb
= NULL
;
1627 const char *printername
;
1628 uint32 mypid
= (uint32
)sys_getpid();
1632 /* if ( snum == -1 ), we are deregister a print server handle
1633 which means to deregister on all print queues */
1637 int num_services
= lp_numservices();
1640 for ( idx
=0; idx
<num_services
; idx
++ ) {
1641 if ( lp_snum_ok(idx
) && lp_print_ok(idx
) )
1642 print_notify_deregister_pid(idx
);
1647 else /* deregister a specific printer */
1649 printername
= lp_const_servicename(snum
);
1650 pdb
= get_print_db_byname(printername
);
1656 if (tdb_lock_bystring(tdb
, NOTIFY_PID_LIST_KEY
, 10) == -1) {
1657 DEBUG(0,("print_notify_register_pid: Failed to lock \
1658 printer %s database\n", printername
));
1660 release_print_db(pdb
);
1664 data
= get_printer_notify_pid_list( tdb
, printername
, True
);
1666 /* Reduce refcount. Remove ourselves if zero. */
1668 for (i
= 0; i
< data
.dsize
; ) {
1669 if (IVAL(data
.dptr
,i
) == mypid
) {
1670 uint32 refcount
= IVAL(data
.dptr
, i
+4);
1674 if (refcount
== 0) {
1675 if (data
.dsize
- i
> 8)
1676 memmove( &data
.dptr
[i
], &data
.dptr
[i
+8], data
.dsize
- i
- 8);
1680 SIVAL(data
.dptr
, i
+4, refcount
);
1686 if (data
.dsize
== 0)
1687 SAFE_FREE(data
.dptr
);
1689 /* Store back the record. */
1690 if (tdb_store_bystring(tdb
, NOTIFY_PID_LIST_KEY
, data
, TDB_REPLACE
) == -1) {
1691 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1692 list for printer %s\n", printername
));
1700 tdb_unlock_bystring(tdb
, NOTIFY_PID_LIST_KEY
);
1702 release_print_db(pdb
);
1703 SAFE_FREE(data
.dptr
);
1707 /****************************************************************************
1708 Check if a jobid is valid. It is valid if it exists in the database.
1709 ****************************************************************************/
1711 BOOL
print_job_exists(const char* sharename
, uint32 jobid
)
1713 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1718 ret
= tdb_exists(pdb
->tdb
, print_key(jobid
));
1719 release_print_db(pdb
);
1723 /****************************************************************************
1724 Give the fd used for a jobid.
1725 ****************************************************************************/
1727 int print_job_fd(const char* sharename
, uint32 jobid
)
1729 struct printjob
*pjob
= print_job_find(sharename
, jobid
);
1732 /* don't allow another process to get this info - it is meaningless */
1733 if (pjob
->pid
!= sys_getpid())
1738 /****************************************************************************
1739 Give the filename used for a jobid.
1740 Only valid for the process doing the spooling and when the job
1741 has not been spooled.
1742 ****************************************************************************/
1744 char *print_job_fname(const char* sharename
, uint32 jobid
)
1746 struct printjob
*pjob
= print_job_find(sharename
, jobid
);
1747 if (!pjob
|| pjob
->spooled
|| pjob
->pid
!= sys_getpid())
1749 return pjob
->filename
;
1753 /****************************************************************************
1754 Give the filename used for a jobid.
1755 Only valid for the process doing the spooling and when the job
1756 has not been spooled.
1757 ****************************************************************************/
1759 NT_DEVICEMODE
*print_job_devmode(const char* sharename
, uint32 jobid
)
1761 struct printjob
*pjob
= print_job_find(sharename
, jobid
);
1766 return pjob
->nt_devmode
;
1769 /****************************************************************************
1770 Set the place in the queue for a job.
1771 ****************************************************************************/
1773 BOOL
print_job_set_place(int snum
, uint32 jobid
, int place
)
1775 DEBUG(2,("print_job_set_place not implemented yet\n"));
1779 /****************************************************************************
1780 Set the name of a job. Only possible for owner.
1781 ****************************************************************************/
1783 BOOL
print_job_set_name(int snum
, uint32 jobid
, char *name
)
1785 const char* sharename
= lp_const_servicename(snum
);
1786 struct printjob
*pjob
;
1788 pjob
= print_job_find(sharename
, jobid
);
1789 if (!pjob
|| pjob
->pid
!= sys_getpid())
1792 fstrcpy(pjob
->jobname
, name
);
1793 return pjob_store(sharename
, jobid
, pjob
);
1796 /***************************************************************************
1797 Remove a jobid from the 'jobs changed' list.
1798 ***************************************************************************/
1800 static BOOL
remove_from_jobs_changed(const char* sharename
, uint32 jobid
)
1802 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1804 size_t job_count
, i
;
1806 BOOL gotlock
= False
;
1814 key
= string_tdb_data("INFO/jobs_changed");
1816 if (tdb_chainlock_with_timeout(pdb
->tdb
, key
, 5) == -1)
1821 data
= tdb_fetch(pdb
->tdb
, key
);
1823 if (data
.dptr
== NULL
|| data
.dsize
== 0 || (data
.dsize
% 4 != 0))
1826 job_count
= data
.dsize
/ 4;
1827 for (i
= 0; i
< job_count
; i
++) {
1830 ch_jobid
= IVAL(data
.dptr
, i
*4);
1831 if (ch_jobid
== jobid
) {
1832 if (i
< job_count
-1 )
1833 memmove(data
.dptr
+ (i
*4), data
.dptr
+ (i
*4) + 4, (job_count
- i
- 1)*4 );
1835 if (tdb_store(pdb
->tdb
, key
, data
, TDB_REPLACE
) == -1)
1845 tdb_chainunlock(pdb
->tdb
, key
);
1846 SAFE_FREE(data
.dptr
);
1847 release_print_db(pdb
);
1849 DEBUG(10,("remove_from_jobs_changed: removed jobid %u\n", (unsigned int)jobid
));
1851 DEBUG(10,("remove_from_jobs_changed: Failed to remove jobid %u\n", (unsigned int)jobid
));
1855 /****************************************************************************
1856 Delete a print job - don't update queue.
1857 ****************************************************************************/
1859 static BOOL
print_job_delete1(int snum
, uint32 jobid
)
1861 const char* sharename
= lp_const_servicename(snum
);
1862 struct printjob
*pjob
= print_job_find(sharename
, jobid
);
1864 struct printif
*current_printif
= get_printer_fns( snum
);
1870 * If already deleting just return.
1873 if (pjob
->status
== LPQ_DELETING
)
1876 /* Hrm - we need to be able to cope with deleting a job before it
1877 has reached the spooler. Just mark it as LPQ_DELETING and
1878 let the print_queue_update() code rmeove the record */
1881 if (pjob
->sysjob
== -1) {
1882 DEBUG(5, ("attempt to delete job %u not seen by lpr\n", (unsigned int)jobid
));
1885 /* Set the tdb entry to be deleting. */
1887 pjob
->status
= LPQ_DELETING
;
1888 pjob_store(sharename
, jobid
, pjob
);
1890 if (pjob
->spooled
&& pjob
->sysjob
!= -1)
1892 result
= (*(current_printif
->job_delete
))(
1894 lp_lprmcommand(snum
),
1897 /* Delete the tdb entry if the delete succeeded or the job hasn't
1901 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1906 pjob_delete(sharename
, jobid
);
1907 /* Ensure we keep a rough count of the number of total jobs... */
1908 tdb_change_int32_atomic(pdb
->tdb
, "INFO/total_jobs", &njobs
, -1);
1909 release_print_db(pdb
);
1913 remove_from_jobs_changed( sharename
, jobid
);
1915 return (result
== 0);
1918 /****************************************************************************
1919 Return true if the current user owns the print job.
1920 ****************************************************************************/
1922 static BOOL
is_owner(struct current_user
*user
, int snum
, uint32 jobid
)
1924 struct printjob
*pjob
= print_job_find(lp_const_servicename(snum
), jobid
);
1930 if ((vuser
= get_valid_user_struct(user
->vuid
)) != NULL
) {
1931 return strequal(pjob
->user
, vuser
->user
.smb_name
);
1933 return strequal(pjob
->user
, uidtoname(user
->ut
.uid
));
1937 /****************************************************************************
1939 ****************************************************************************/
1941 BOOL
print_job_delete(struct current_user
*user
, int snum
, uint32 jobid
, WERROR
*errcode
)
1943 const char* sharename
= lp_const_servicename( snum
);
1944 struct printjob
*pjob
;
1950 owner
= is_owner(user
, snum
, jobid
);
1952 /* Check access against security descriptor or whether the user
1956 !print_access_check(user
, snum
, JOB_ACCESS_ADMINISTER
)) {
1957 DEBUG(3, ("delete denied by security descriptor\n"));
1958 *errcode
= WERR_ACCESS_DENIED
;
1960 /* BEGIN_ADMIN_LOG */
1961 sys_adminlog( LOG_ERR
,
1962 "Permission denied-- user not allowed to delete, \
1963 pause, or resume print job. User name: %s. Printer name: %s.",
1964 uidtoname(user
->ut
.uid
), PRINTERNAME(snum
) );
1971 * get the spooled filename of the print job
1972 * if this works, then the file has not been spooled
1973 * to the underlying print system. Just delete the
1974 * spool file & return.
1977 if ( (fname
= print_job_fname( sharename
, jobid
)) != NULL
)
1979 /* remove the spool file */
1980 DEBUG(10,("print_job_delete: Removing spool file [%s]\n", fname
));
1981 if ( unlink( fname
) == -1 ) {
1982 *errcode
= map_werror_from_unix(errno
);
1987 if (!print_job_delete1(snum
, jobid
)) {
1988 *errcode
= WERR_ACCESS_DENIED
;
1992 /* force update the database and say the delete failed if the
1995 print_queue_update(snum
, True
);
1997 pjob
= print_job_find(sharename
, jobid
);
1998 if ( pjob
&& (pjob
->status
!= LPQ_DELETING
) )
1999 *errcode
= WERR_ACCESS_DENIED
;
2001 return (pjob
== NULL
);
2004 /****************************************************************************
2006 ****************************************************************************/
2008 BOOL
print_job_pause(struct current_user
*user
, int snum
, uint32 jobid
, WERROR
*errcode
)
2010 const char* sharename
= lp_const_servicename(snum
);
2011 struct printjob
*pjob
;
2013 struct printif
*current_printif
= get_printer_fns( snum
);
2015 pjob
= print_job_find(sharename
, jobid
);
2020 if (!pjob
->spooled
|| pjob
->sysjob
== -1)
2023 if (!is_owner(user
, snum
, jobid
) &&
2024 !print_access_check(user
, snum
, JOB_ACCESS_ADMINISTER
)) {
2025 DEBUG(3, ("pause denied by security descriptor\n"));
2027 /* BEGIN_ADMIN_LOG */
2028 sys_adminlog( LOG_ERR
,
2029 "Permission denied-- user not allowed to delete, \
2030 pause, or resume print job. User name: %s. Printer name: %s.",
2031 uidtoname(user
->ut
.uid
), PRINTERNAME(snum
) );
2034 *errcode
= WERR_ACCESS_DENIED
;
2038 /* need to pause the spooled entry */
2039 ret
= (*(current_printif
->job_pause
))(snum
, pjob
);
2042 *errcode
= WERR_INVALID_PARAM
;
2046 /* force update the database */
2047 print_cache_flush(snum
);
2049 /* Send a printer notify message */
2051 notify_job_status(sharename
, jobid
, JOB_STATUS_PAUSED
);
2053 /* how do we tell if this succeeded? */
2058 /****************************************************************************
2060 ****************************************************************************/
2062 BOOL
print_job_resume(struct current_user
*user
, int snum
, uint32 jobid
, WERROR
*errcode
)
2064 const char *sharename
= lp_const_servicename(snum
);
2065 struct printjob
*pjob
;
2067 struct printif
*current_printif
= get_printer_fns( snum
);
2069 pjob
= print_job_find(sharename
, jobid
);
2074 if (!pjob
->spooled
|| pjob
->sysjob
== -1)
2077 if (!is_owner(user
, snum
, jobid
) &&
2078 !print_access_check(user
, snum
, JOB_ACCESS_ADMINISTER
)) {
2079 DEBUG(3, ("resume denied by security descriptor\n"));
2080 *errcode
= WERR_ACCESS_DENIED
;
2082 /* BEGIN_ADMIN_LOG */
2083 sys_adminlog( LOG_ERR
,
2084 "Permission denied-- user not allowed to delete, \
2085 pause, or resume print job. User name: %s. Printer name: %s.",
2086 uidtoname(user
->ut
.uid
), PRINTERNAME(snum
) );
2091 ret
= (*(current_printif
->job_resume
))(snum
, pjob
);
2094 *errcode
= WERR_INVALID_PARAM
;
2098 /* force update the database */
2099 print_cache_flush(snum
);
2101 /* Send a printer notify message */
2103 notify_job_status(sharename
, jobid
, JOB_STATUS_QUEUED
);
2108 /****************************************************************************
2109 Write to a print file.
2110 ****************************************************************************/
2112 ssize_t
print_job_write(int snum
, uint32 jobid
, const char *buf
, SMB_OFF_T pos
, size_t size
)
2114 const char* sharename
= lp_const_servicename(snum
);
2116 struct printjob
*pjob
;
2118 pjob
= print_job_find(sharename
, jobid
);
2122 /* don't allow another process to get this info - it is meaningless */
2123 if (pjob
->pid
!= sys_getpid())
2126 return_code
= write_data_at_offset(pjob
->fd
, buf
, size
, pos
);
2128 if (return_code
>0) {
2130 pjob_store(sharename
, jobid
, pjob
);
2135 /****************************************************************************
2136 Get the queue status - do not update if db is out of date.
2137 ****************************************************************************/
2139 static int get_queue_status(const char* sharename
, print_status_struct
*status
)
2143 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
2147 ZERO_STRUCTP(status
);
2154 fstr_sprintf(keystr
, "STATUS/%s", sharename
);
2155 data
= tdb_fetch(pdb
->tdb
, string_tdb_data(keystr
));
2157 if (data
.dsize
== sizeof(print_status_struct
))
2158 /* this memcpy is ok since the status struct was
2159 not packed before storing it in the tdb */
2160 memcpy(status
, data
.dptr
, sizeof(print_status_struct
));
2161 SAFE_FREE(data
.dptr
);
2164 len
= tdb_fetch_int32(pdb
->tdb
, "INFO/total_jobs");
2165 release_print_db(pdb
);
2166 return (len
== -1 ? 0 : len
);
2169 /****************************************************************************
2170 Determine the number of jobs in a queue.
2171 ****************************************************************************/
2173 int print_queue_length(int snum
, print_status_struct
*pstatus
)
2175 const char* sharename
= lp_const_servicename( snum
);
2176 print_status_struct status
;
2179 ZERO_STRUCT( status
);
2181 /* make sure the database is up to date */
2182 if (print_cache_expired(lp_const_servicename(snum
), True
))
2183 print_queue_update(snum
, False
);
2185 /* also fetch the queue status */
2186 memset(&status
, 0, sizeof(status
));
2187 len
= get_queue_status(sharename
, &status
);
2195 /***************************************************************************
2196 Allocate a jobid. Hold the lock for as short a time as possible.
2197 ***************************************************************************/
2199 static BOOL
allocate_print_jobid(struct tdb_print_db
*pdb
, int snum
, const char *sharename
, uint32
*pjobid
)
2204 *pjobid
= (uint32
)-1;
2206 for (i
= 0; i
< 3; i
++) {
2207 /* Lock the database - only wait 20 seconds. */
2208 if (tdb_lock_bystring(pdb
->tdb
, "INFO/nextjob", 20) == -1) {
2209 DEBUG(0,("allocate_print_jobid: failed to lock printing database %s\n", sharename
));
2213 if (!tdb_fetch_uint32(pdb
->tdb
, "INFO/nextjob", &jobid
)) {
2214 if (tdb_error(pdb
->tdb
) != TDB_ERR_NOEXIST
) {
2215 DEBUG(0, ("allocate_print_jobid: failed to fetch INFO/nextjob for print queue %s\n",
2222 jobid
= NEXT_JOBID(jobid
);
2224 if (tdb_store_int32(pdb
->tdb
, "INFO/nextjob", jobid
)==-1) {
2225 DEBUG(3, ("allocate_print_jobid: failed to store INFO/nextjob.\n"));
2226 tdb_unlock_bystring(pdb
->tdb
, "INFO/nextjob");
2230 /* We've finished with the INFO/nextjob lock. */
2231 tdb_unlock_bystring(pdb
->tdb
, "INFO/nextjob");
2233 if (!print_job_exists(sharename
, jobid
))
2238 DEBUG(0, ("allocate_print_jobid: failed to allocate a print job for queue %s\n",
2240 /* Probably full... */
2245 /* Store a dummy placeholder. */
2250 if (tdb_store(pdb
->tdb
, print_key(jobid
), dum
, TDB_INSERT
) == -1) {
2251 DEBUG(3, ("allocate_print_jobid: jobid (%d) failed to store placeholder.\n",
2261 /***************************************************************************
2262 Append a jobid to the 'jobs changed' list.
2263 ***************************************************************************/
2265 static BOOL
add_to_jobs_changed(struct tdb_print_db
*pdb
, uint32 jobid
)
2270 SIVAL(&store_jobid
, 0, jobid
);
2271 data
.dptr
= (char *)&store_jobid
;
2274 DEBUG(10,("add_to_jobs_changed: Added jobid %u\n", (unsigned int)jobid
));
2276 return (tdb_append(pdb
->tdb
, string_tdb_data("INFO/jobs_changed"),
2280 /***************************************************************************
2281 Start spooling a job - return the jobid.
2282 ***************************************************************************/
2284 uint32
print_job_start(struct current_user
*user
, int snum
, char *jobname
, NT_DEVICEMODE
*nt_devmode
)
2288 struct printjob pjob
;
2290 const char *sharename
= lp_const_servicename(snum
);
2291 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
2299 if (!print_access_check(user
, snum
, PRINTER_ACCESS_USE
)) {
2300 DEBUG(3, ("print_job_start: job start denied by security descriptor\n"));
2301 release_print_db(pdb
);
2305 if (!print_time_access_check(snum
)) {
2306 DEBUG(3, ("print_job_start: job start denied by time check\n"));
2307 release_print_db(pdb
);
2311 path
= lp_pathname(snum
);
2313 /* see if we have sufficient disk space */
2314 if (lp_minprintspace(snum
)) {
2315 SMB_BIG_UINT dspace
, dsize
;
2316 if (sys_fsusage(path
, &dspace
, &dsize
) == 0 &&
2317 dspace
< 2*(SMB_BIG_UINT
)lp_minprintspace(snum
)) {
2318 DEBUG(3, ("print_job_start: disk space check failed.\n"));
2319 release_print_db(pdb
);
2325 /* for autoloaded printers, check that the printcap entry still exists */
2326 if (lp_autoloaded(snum
) && !pcap_printername_ok(lp_const_servicename(snum
))) {
2327 DEBUG(3, ("print_job_start: printer name %s check failed.\n", lp_const_servicename(snum
) ));
2328 release_print_db(pdb
);
2333 /* Insure the maximum queue size is not violated */
2334 if ((njobs
= print_queue_length(snum
,NULL
)) > lp_maxprintjobs(snum
)) {
2335 DEBUG(3, ("print_job_start: Queue %s number of jobs (%d) larger than max printjobs per queue (%d).\n",
2336 sharename
, njobs
, lp_maxprintjobs(snum
) ));
2337 release_print_db(pdb
);
2342 DEBUG(10,("print_job_start: Queue %s number of jobs (%d), max printjobs = %d\n",
2343 sharename
, njobs
, lp_maxprintjobs(snum
) ));
2345 if (!allocate_print_jobid(pdb
, snum
, sharename
, &jobid
))
2348 /* create the database entry */
2352 pjob
.pid
= sys_getpid();
2355 pjob
.starttime
= time(NULL
);
2356 pjob
.status
= LPQ_SPOOLING
;
2358 pjob
.spooled
= False
;
2360 pjob
.nt_devmode
= nt_devmode
;
2362 fstrcpy(pjob
.jobname
, jobname
);
2364 if ((vuser
= get_valid_user_struct(user
->vuid
)) != NULL
) {
2365 fstrcpy(pjob
.user
, vuser
->user
.smb_name
);
2367 fstrcpy(pjob
.user
, uidtoname(user
->ut
.uid
));
2370 fstrcpy(pjob
.queuename
, lp_const_servicename(snum
));
2372 /* we have a job entry - now create the spool file */
2373 slprintf(pjob
.filename
, sizeof(pjob
.filename
)-1, "%s/%s%.8u.XXXXXX",
2374 path
, PRINT_SPOOL_PREFIX
, (unsigned int)jobid
);
2375 pjob
.fd
= smb_mkstemp(pjob
.filename
);
2377 if (pjob
.fd
== -1) {
2378 if (errno
== EACCES
) {
2379 /* Common setup error, force a report. */
2380 DEBUG(0, ("print_job_start: insufficient permissions \
2381 to open spool file %s.\n", pjob
.filename
));
2383 /* Normal case, report at level 3 and above. */
2384 DEBUG(3, ("print_job_start: can't open spool file %s,\n", pjob
.filename
));
2385 DEBUGADD(3, ("errno = %d (%s).\n", errno
, strerror(errno
)));
2390 pjob_store(sharename
, jobid
, &pjob
);
2392 /* Update the 'jobs changed' entry used by print_queue_status. */
2393 add_to_jobs_changed(pdb
, jobid
);
2395 /* Ensure we keep a rough count of the number of total jobs... */
2396 tdb_change_int32_atomic(pdb
->tdb
, "INFO/total_jobs", &njobs
, 1);
2398 release_print_db(pdb
);
2404 pjob_delete(sharename
, jobid
);
2406 release_print_db(pdb
);
2408 DEBUG(3, ("print_job_start: returning fail. Error = %s\n", strerror(errno
) ));
2412 /****************************************************************************
2413 Update the number of pages spooled to jobid
2414 ****************************************************************************/
2416 void print_job_endpage(int snum
, uint32 jobid
)
2418 const char* sharename
= lp_const_servicename(snum
);
2419 struct printjob
*pjob
;
2421 pjob
= print_job_find(sharename
, jobid
);
2424 /* don't allow another process to get this info - it is meaningless */
2425 if (pjob
->pid
!= sys_getpid())
2429 pjob_store(sharename
, jobid
, pjob
);
2432 /****************************************************************************
2433 Print a file - called on closing the file. This spools the job.
2434 If normal close is false then we're tearing down the jobs - treat as an
2436 ****************************************************************************/
2438 BOOL
print_job_end(int snum
, uint32 jobid
, enum file_close_type close_type
)
2440 const char* sharename
= lp_const_servicename(snum
);
2441 struct printjob
*pjob
;
2443 SMB_STRUCT_STAT sbuf
;
2444 struct printif
*current_printif
= get_printer_fns( snum
);
2446 pjob
= print_job_find(sharename
, jobid
);
2451 if (pjob
->spooled
|| pjob
->pid
!= sys_getpid())
2454 if ((close_type
== NORMAL_CLOSE
|| close_type
== SHUTDOWN_CLOSE
) &&
2455 (sys_fstat(pjob
->fd
, &sbuf
) == 0)) {
2456 pjob
->size
= sbuf
.st_size
;
2462 * Not a normal close or we couldn't stat the job file,
2463 * so something has gone wrong. Cleanup.
2467 DEBUG(3,("print_job_end: failed to stat file for jobid %d\n", jobid
));
2471 /* Technically, this is not quite right. If the printer has a separator
2472 * page turned on, the NT spooler prints the separator page even if the
2473 * print job is 0 bytes. 010215 JRR */
2474 if (pjob
->size
== 0 || pjob
->status
== LPQ_DELETING
) {
2475 /* don't bother spooling empty files or something being deleted. */
2476 DEBUG(5,("print_job_end: canceling spool of %s (%s)\n",
2477 pjob
->filename
, pjob
->size
? "deleted" : "zero length" ));
2478 unlink(pjob
->filename
);
2479 pjob_delete(sharename
, jobid
);
2483 pjob
->smbjob
= jobid
;
2485 ret
= (*(current_printif
->job_submit
))(snum
, pjob
);
2490 /* The print job has been sucessfully handed over to the back-end */
2492 pjob
->spooled
= True
;
2493 pjob
->status
= LPQ_QUEUED
;
2494 pjob_store(sharename
, jobid
, pjob
);
2496 /* make sure the database is up to date */
2497 if (print_cache_expired(lp_const_servicename(snum
), True
))
2498 print_queue_update(snum
, False
);
2504 /* The print job was not succesfully started. Cleanup */
2505 /* Still need to add proper error return propagation! 010122:JRR */
2506 unlink(pjob
->filename
);
2507 pjob_delete(sharename
, jobid
);
2511 /****************************************************************************
2512 Get a snapshot of jobs in the system without traversing.
2513 ****************************************************************************/
2515 static BOOL
get_stored_queue_info(struct tdb_print_db
*pdb
, int snum
, int *pcount
, print_queue_struct
**ppqueue
)
2517 TDB_DATA data
, cgdata
;
2518 print_queue_struct
*queue
= NULL
;
2520 uint32 extra_count
= 0;
2521 int total_count
= 0;
2524 int max_reported_jobs
= lp_max_reported_jobs(snum
);
2526 const char* sharename
= lp_servicename(snum
);
2528 /* make sure the database is up to date */
2529 if (print_cache_expired(lp_const_servicename(snum
), True
))
2530 print_queue_update(snum
, False
);
2536 ZERO_STRUCT(cgdata
);
2538 /* Get the stored queue data. */
2539 data
= tdb_fetch(pdb
->tdb
, string_tdb_data("INFO/linear_queue_array"));
2541 if (data
.dptr
&& data
.dsize
>= sizeof(qcount
))
2542 len
+= tdb_unpack(data
.dptr
+ len
, data
.dsize
- len
, "d", &qcount
);
2544 /* Get the changed jobs list. */
2545 cgdata
= tdb_fetch(pdb
->tdb
, string_tdb_data("INFO/jobs_changed"));
2546 if (cgdata
.dptr
!= NULL
&& (cgdata
.dsize
% 4 == 0))
2547 extra_count
= cgdata
.dsize
/4;
2549 DEBUG(5,("get_stored_queue_info: qcount = %u, extra_count = %u\n", (unsigned int)qcount
, (unsigned int)extra_count
));
2551 /* Allocate the queue size. */
2552 if (qcount
== 0 && extra_count
== 0)
2555 if ((queue
= SMB_MALLOC_ARRAY(print_queue_struct
, qcount
+ extra_count
)) == NULL
)
2558 /* Retrieve the linearised queue data. */
2560 for( i
= 0; i
< qcount
; i
++) {
2561 uint32 qjob
, qsize
, qpage_count
, qstatus
, qpriority
, qtime
;
2562 len
+= tdb_unpack(data
.dptr
+ len
, data
.dsize
- len
, "ddddddff",
2571 queue
[i
].job
= qjob
;
2572 queue
[i
].size
= qsize
;
2573 queue
[i
].page_count
= qpage_count
;
2574 queue
[i
].status
= qstatus
;
2575 queue
[i
].priority
= qpriority
;
2576 queue
[i
].time
= qtime
;
2579 total_count
= qcount
;
2581 /* Add in the changed jobids. */
2582 for( i
= 0; i
< extra_count
; i
++) {
2584 struct printjob
*pjob
;
2586 jobid
= IVAL(cgdata
.dptr
, i
*4);
2587 DEBUG(5,("get_stored_queue_info: changed job = %u\n", (unsigned int)jobid
));
2588 pjob
= print_job_find(lp_const_servicename(snum
), jobid
);
2590 DEBUG(5,("get_stored_queue_info: failed to find changed job = %u\n", (unsigned int)jobid
));
2591 remove_from_jobs_changed(sharename
, jobid
);
2595 queue
[total_count
].job
= jobid
;
2596 queue
[total_count
].size
= pjob
->size
;
2597 queue
[total_count
].page_count
= pjob
->page_count
;
2598 queue
[total_count
].status
= pjob
->status
;
2599 queue
[total_count
].priority
= 1;
2600 queue
[total_count
].time
= pjob
->starttime
;
2601 fstrcpy(queue
[total_count
].fs_user
, pjob
->user
);
2602 fstrcpy(queue
[total_count
].fs_file
, pjob
->jobname
);
2606 /* Sort the queue by submission time otherwise they are displayed
2609 qsort(queue
, total_count
, sizeof(print_queue_struct
), QSORT_CAST(printjob_comp
));
2611 DEBUG(5,("get_stored_queue_info: total_count = %u\n", (unsigned int)total_count
));
2613 if (max_reported_jobs
&& total_count
> max_reported_jobs
)
2614 total_count
= max_reported_jobs
;
2617 *pcount
= total_count
;
2623 SAFE_FREE(data
.dptr
);
2624 SAFE_FREE(cgdata
.dptr
);
2628 /****************************************************************************
2629 Get a printer queue listing.
2630 set queue = NULL and status = NULL if you just want to update the cache
2631 ****************************************************************************/
2633 int print_queue_status(int snum
,
2634 print_queue_struct
**ppqueue
,
2635 print_status_struct
*status
)
2639 const char *sharename
;
2640 struct tdb_print_db
*pdb
;
2643 /* make sure the database is up to date */
2645 if (print_cache_expired(lp_const_servicename(snum
), True
))
2646 print_queue_update(snum
, False
);
2648 /* return if we are done */
2649 if ( !ppqueue
|| !status
)
2653 sharename
= lp_const_servicename(snum
);
2654 pdb
= get_print_db_byname(sharename
);
2660 * Fetch the queue status. We must do this first, as there may
2661 * be no jobs in the queue.
2664 ZERO_STRUCTP(status
);
2665 slprintf(keystr
, sizeof(keystr
)-1, "STATUS/%s", sharename
);
2667 key
.dsize
= strlen(keystr
);
2668 data
= tdb_fetch(pdb
->tdb
, key
);
2670 if (data
.dsize
== sizeof(*status
)) {
2671 /* this memcpy is ok since the status struct was
2672 not packed before storing it in the tdb */
2673 memcpy(status
, data
.dptr
, sizeof(*status
));
2675 SAFE_FREE(data
.dptr
);
2679 * Now, fetch the print queue information. We first count the number
2680 * of entries, and then only retrieve the queue if necessary.
2683 if (!get_stored_queue_info(pdb
, snum
, &count
, ppqueue
)) {
2684 release_print_db(pdb
);
2688 release_print_db(pdb
);
2692 /****************************************************************************
2694 ****************************************************************************/
2696 BOOL
print_queue_pause(struct current_user
*user
, int snum
, WERROR
*errcode
)
2699 struct printif
*current_printif
= get_printer_fns( snum
);
2701 if (!print_access_check(user
, snum
, PRINTER_ACCESS_ADMINISTER
)) {
2702 *errcode
= WERR_ACCESS_DENIED
;
2709 ret
= (*(current_printif
->queue_pause
))(snum
);
2714 *errcode
= WERR_INVALID_PARAM
;
2718 /* force update the database */
2719 print_cache_flush(snum
);
2721 /* Send a printer notify message */
2723 notify_printer_status(snum
, PRINTER_STATUS_PAUSED
);
2728 /****************************************************************************
2730 ****************************************************************************/
2732 BOOL
print_queue_resume(struct current_user
*user
, int snum
, WERROR
*errcode
)
2735 struct printif
*current_printif
= get_printer_fns( snum
);
2737 if (!print_access_check(user
, snum
, PRINTER_ACCESS_ADMINISTER
)) {
2738 *errcode
= WERR_ACCESS_DENIED
;
2744 ret
= (*(current_printif
->queue_resume
))(snum
);
2749 *errcode
= WERR_INVALID_PARAM
;
2753 /* make sure the database is up to date */
2754 if (print_cache_expired(lp_const_servicename(snum
), True
))
2755 print_queue_update(snum
, True
);
2757 /* Send a printer notify message */
2759 notify_printer_status(snum
, PRINTER_STATUS_OK
);
2764 /****************************************************************************
2765 Purge a queue - implemented by deleting all jobs that we can delete.
2766 ****************************************************************************/
2768 BOOL
print_queue_purge(struct current_user
*user
, int snum
, WERROR
*errcode
)
2770 print_queue_struct
*queue
;
2771 print_status_struct status
;
2775 /* Force and update so the count is accurate (i.e. not a cached count) */
2776 print_queue_update(snum
, True
);
2778 can_job_admin
= print_access_check(user
, snum
, JOB_ACCESS_ADMINISTER
);
2779 njobs
= print_queue_status(snum
, &queue
, &status
);
2781 if ( can_job_admin
)
2784 for (i
=0;i
<njobs
;i
++) {
2785 BOOL owner
= is_owner(user
, snum
, queue
[i
].job
);
2787 if (owner
|| can_job_admin
) {
2788 print_job_delete1(snum
, queue
[i
].job
);
2792 if ( can_job_admin
)
2795 /* update the cache */
2796 print_queue_update( snum
, True
);