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 3 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, see <http://www.gnu.org/licenses/>.
23 #include "system/syslog.h"
24 #include "system/filesys.h"
26 #include "../librpc/gen_ndr/ndr_spoolss.h"
27 #include "nt_printing.h"
28 #include "../librpc/gen_ndr/netlogon.h"
29 #include "printing/notify.h"
30 #include "printing/pcap.h"
31 #include "printing/printer_list.h"
32 #include "printing/queue_process.h"
34 #include "smbd/smbd.h"
38 #include "lib/param/loadparm.h"
40 extern struct current_user current_user
;
41 extern userdom_struct current_user_info
;
43 /* Current printer interface */
44 static bool remove_from_jobs_added(const char* sharename
, uint32 jobid
);
47 the printing backend revolves around a tdb database that stores the
48 SMB view of the print queue
50 The key for this database is a jobid - a internally generated number that
51 uniquely identifies a print job
53 reading the print queue involves two steps:
54 - possibly running lpq and updating the internal database from that
55 - reading entries from the database
57 jobids are assigned when a job starts spooling.
60 static TDB_CONTEXT
*rap_tdb
;
61 static uint16 next_rap_jobid
;
62 struct rap_jobid_key
{
67 /***************************************************************************
68 Nightmare. LANMAN jobid's are 16 bit numbers..... We must map them to 32
69 bit RPC jobids.... JRA.
70 ***************************************************************************/
72 uint16
pjobid_to_rap(const char* sharename
, uint32 jobid
)
76 struct rap_jobid_key jinfo
;
79 DEBUG(10,("pjobid_to_rap: called.\n"));
82 /* Create the in-memory tdb. */
83 rap_tdb
= tdb_open_log(NULL
, 0, TDB_INTERNAL
, (O_RDWR
|O_CREAT
), 0644);
89 fstrcpy( jinfo
.sharename
, sharename
);
91 key
.dptr
= (uint8
*)&jinfo
;
92 key
.dsize
= sizeof(jinfo
);
94 data
= tdb_fetch_compat(rap_tdb
, key
);
95 if (data
.dptr
&& data
.dsize
== sizeof(uint16
)) {
96 rap_jobid
= SVAL(data
.dptr
, 0);
98 DEBUG(10,("pjobid_to_rap: jobid %u maps to RAP jobid %u\n",
99 (unsigned int)jobid
, (unsigned int)rap_jobid
));
102 SAFE_FREE(data
.dptr
);
103 /* Not found - create and store mapping. */
104 rap_jobid
= ++next_rap_jobid
;
106 rap_jobid
= ++next_rap_jobid
;
107 SSVAL(buf
,0,rap_jobid
);
109 data
.dsize
= sizeof(rap_jobid
);
110 tdb_store(rap_tdb
, key
, data
, TDB_REPLACE
);
111 tdb_store(rap_tdb
, data
, key
, TDB_REPLACE
);
113 DEBUG(10,("pjobid_to_rap: created jobid %u maps to RAP jobid %u\n",
114 (unsigned int)jobid
, (unsigned int)rap_jobid
));
118 bool rap_to_pjobid(uint16 rap_jobid
, fstring sharename
, uint32
*pjobid
)
123 DEBUG(10,("rap_to_pjobid called.\n"));
128 SSVAL(buf
,0,rap_jobid
);
130 key
.dsize
= sizeof(rap_jobid
);
131 data
= tdb_fetch_compat(rap_tdb
, key
);
132 if ( data
.dptr
&& data
.dsize
== sizeof(struct rap_jobid_key
) )
134 struct rap_jobid_key
*jinfo
= (struct rap_jobid_key
*)data
.dptr
;
135 if (sharename
!= NULL
) {
136 fstrcpy( sharename
, jinfo
->sharename
);
138 *pjobid
= jinfo
->jobid
;
139 DEBUG(10,("rap_to_pjobid: jobid %u maps to RAP jobid %u\n",
140 (unsigned int)*pjobid
, (unsigned int)rap_jobid
));
141 SAFE_FREE(data
.dptr
);
145 DEBUG(10,("rap_to_pjobid: Failed to lookup RAP jobid %u\n",
146 (unsigned int)rap_jobid
));
147 SAFE_FREE(data
.dptr
);
151 void rap_jobid_delete(const char* sharename
, uint32 jobid
)
155 struct rap_jobid_key jinfo
;
158 DEBUG(10,("rap_jobid_delete: called.\n"));
163 ZERO_STRUCT( jinfo
);
164 fstrcpy( jinfo
.sharename
, sharename
);
166 key
.dptr
= (uint8
*)&jinfo
;
167 key
.dsize
= sizeof(jinfo
);
169 data
= tdb_fetch_compat(rap_tdb
, key
);
170 if (!data
.dptr
|| (data
.dsize
!= sizeof(uint16
))) {
171 DEBUG(10,("rap_jobid_delete: cannot find jobid %u\n",
172 (unsigned int)jobid
));
173 SAFE_FREE(data
.dptr
);
177 DEBUG(10,("rap_jobid_delete: deleting jobid %u\n",
178 (unsigned int)jobid
));
180 rap_jobid
= SVAL(data
.dptr
, 0);
181 SAFE_FREE(data
.dptr
);
182 SSVAL(buf
,0,rap_jobid
);
184 data
.dsize
= sizeof(rap_jobid
);
185 tdb_delete(rap_tdb
, key
);
186 tdb_delete(rap_tdb
, data
);
189 static int get_queue_status(const char* sharename
, print_status_struct
*);
191 /****************************************************************************
192 Initialise the printing backend. Called once at startup before the fork().
193 ****************************************************************************/
195 bool print_backend_init(struct messaging_context
*msg_ctx
)
197 const char *sversion
= "INFO/version";
198 int services
= lp_numservices();
202 if (!printer_list_parent_init()) {
206 ok
= directory_create_or_exist(cache_path("printing"), geteuid(), 0755);
211 unlink(cache_path("printing.tdb"));
213 /* handle a Samba upgrade */
215 for (snum
= 0; snum
< services
; snum
++) {
216 struct tdb_print_db
*pdb
;
217 if (!lp_print_ok(snum
))
220 pdb
= get_print_db_byname(lp_const_servicename(snum
));
223 if (tdb_lock_bystring(pdb
->tdb
, sversion
) != 0) {
224 DEBUG(0,("print_backend_init: Failed to open printer %s database\n", lp_const_servicename(snum
) ));
225 release_print_db(pdb
);
228 if (tdb_fetch_int32(pdb
->tdb
, sversion
) != PRINT_DATABASE_VERSION
) {
229 tdb_wipe_all(pdb
->tdb
);
230 tdb_store_int32(pdb
->tdb
, sversion
, PRINT_DATABASE_VERSION
);
232 tdb_unlock_bystring(pdb
->tdb
, sversion
);
233 release_print_db(pdb
);
236 close_all_print_db(); /* Don't leave any open. */
238 /* do NT print initialization... */
239 return nt_printing_init(msg_ctx
);
242 /****************************************************************************
243 Shut down printing backend. Called once at shutdown to close the tdb.
244 ****************************************************************************/
246 void printing_end(void)
248 close_all_print_db(); /* Don't leave any open. */
251 /****************************************************************************
252 Retrieve the set of printing functions for a given service. This allows
253 us to set the printer function table based on the value of the 'printing'
256 Use the generic interface as the default and only use cups interface only
257 when asked for (and only when supported)
258 ****************************************************************************/
260 static struct printif
*get_printer_fns_from_type( enum printing_types type
)
262 struct printif
*printer_fns
= &generic_printif
;
265 if ( type
== PRINT_CUPS
) {
266 printer_fns
= &cups_printif
;
268 #endif /* HAVE_CUPS */
271 if ( type
== PRINT_IPRINT
) {
272 printer_fns
= &iprint_printif
;
274 #endif /* HAVE_IPRINT */
276 printer_fns
->type
= type
;
281 static struct printif
*get_printer_fns( int snum
)
283 return get_printer_fns_from_type( (enum printing_types
)lp_printing(snum
) );
287 /****************************************************************************
288 Useful function to generate a tdb key.
289 ****************************************************************************/
291 static TDB_DATA
print_key(uint32 jobid
, uint32
*tmp
)
295 SIVAL(tmp
, 0, jobid
);
296 ret
.dptr
= (uint8
*)tmp
;
297 ret
.dsize
= sizeof(*tmp
);
301 /****************************************************************************
302 Pack the devicemode to store it in a tdb.
303 ****************************************************************************/
304 static int pack_devicemode(struct spoolss_DeviceMode
*devmode
, uint8
*buf
, int buflen
)
306 enum ndr_err_code ndr_err
;
311 ndr_err
= ndr_push_struct_blob(&blob
, talloc_tos(),
313 (ndr_push_flags_fn_t
)
314 ndr_push_spoolss_DeviceMode
);
315 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
316 DEBUG(10, ("pack_devicemode: "
317 "error encoding spoolss_DeviceMode\n"));
324 len
= tdb_pack(buf
, buflen
, "B", blob
.length
, blob
.data
);
327 DEBUG(8, ("Packed devicemode [%s]\n", devmode
->formname
));
334 /****************************************************************************
335 Unpack the devicemode to store it in a tdb.
336 ****************************************************************************/
337 static int unpack_devicemode(TALLOC_CTX
*mem_ctx
,
338 const uint8
*buf
, int buflen
,
339 struct spoolss_DeviceMode
**devmode
)
341 struct spoolss_DeviceMode
*dm
;
342 enum ndr_err_code ndr_err
;
350 len
= tdb_unpack(buf
, buflen
, "B", &data_len
, &data
);
355 dm
= talloc_zero(mem_ctx
, struct spoolss_DeviceMode
);
360 blob
= data_blob_const(data
, data_len
);
362 ndr_err
= ndr_pull_struct_blob(&blob
, dm
, dm
,
363 (ndr_pull_flags_fn_t
)ndr_pull_spoolss_DeviceMode
);
364 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
365 DEBUG(10, ("unpack_devicemode: "
366 "error parsing spoolss_DeviceMode\n"));
370 DEBUG(8, ("Unpacked devicemode [%s](%s)\n",
371 dm
->devicename
, dm
->formname
));
372 if (dm
->driverextra_data
.data
) {
373 DEBUG(8, ("with a private section of %d bytes\n",
374 dm
->__driverextra_length
));
384 /***********************************************************************
385 unpack a pjob from a tdb buffer
386 ***********************************************************************/
388 static int unpack_pjob(TALLOC_CTX
*mem_ctx
, uint8
*buf
, int buflen
,
389 struct printjob
*pjob
)
393 uint32 pjpid
, pjjobid
, pjsysjob
, pjfd
, pjstarttime
, pjstatus
;
394 uint32 pjsize
, pjpage_count
, pjspooled
, pjsmbjob
;
400 len
+= tdb_unpack(buf
+len
, buflen
-len
, "ddddddddddfffff",
421 used
= unpack_devicemode(mem_ctx
, buf
+len
, buflen
-len
, &pjob
->devmode
);
429 pjob
->jobid
= pjjobid
;
430 pjob
->sysjob
= pjsysjob
;
432 pjob
->starttime
= pjstarttime
;
433 pjob
->status
= pjstatus
;
435 pjob
->page_count
= pjpage_count
;
436 pjob
->spooled
= pjspooled
;
437 pjob
->smbjob
= pjsmbjob
;
443 /****************************************************************************
444 Useful function to find a print job in the database.
445 ****************************************************************************/
447 static struct printjob
*print_job_find(TALLOC_CTX
*mem_ctx
,
448 const char *sharename
,
451 struct printjob
*pjob
;
454 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
456 DEBUG(10,("print_job_find: looking up job %u for share %s\n",
457 (unsigned int)jobid
, sharename
));
463 ret
= tdb_fetch_compat(pdb
->tdb
, print_key(jobid
, &tmp
));
464 release_print_db(pdb
);
467 DEBUG(10, ("print_job_find: failed to find jobid %u.\n",
472 pjob
= talloc_zero(mem_ctx
, struct printjob
);
477 if (unpack_pjob(mem_ctx
, ret
.dptr
, ret
.dsize
, pjob
) == -1) {
478 DEBUG(10, ("failed to unpack jobid %u.\n", jobid
));
484 DEBUG(10,("print_job_find: returning system job %d for jobid %u.\n",
485 pjob
->sysjob
, jobid
));
486 SMB_ASSERT(pjob
->jobid
== jobid
);
493 /* Convert a unix jobid to a smb jobid */
495 struct unixjob_traverse_state
{
497 uint32 sysjob_to_jobid_value
;
500 static int unixjob_traverse_fn(TDB_CONTEXT
*the_tdb
, TDB_DATA key
,
501 TDB_DATA data
, void *private_data
)
503 struct printjob
*pjob
;
504 struct unixjob_traverse_state
*state
=
505 (struct unixjob_traverse_state
*)private_data
;
507 if (!data
.dptr
|| data
.dsize
== 0)
510 pjob
= (struct printjob
*)data
.dptr
;
511 if (key
.dsize
!= sizeof(uint32
))
514 if (state
->sysjob
== pjob
->sysjob
) {
515 state
->sysjob_to_jobid_value
= pjob
->jobid
;
522 uint32
sysjob_to_jobid_pdb(struct tdb_print_db
*pdb
, int sysjob
)
524 struct unixjob_traverse_state state
;
526 state
.sysjob
= sysjob
;
527 state
.sysjob_to_jobid_value
= (uint32
)-1;
529 tdb_traverse(pdb
->tdb
, unixjob_traverse_fn
, &state
);
531 return state
.sysjob_to_jobid_value
;
534 /****************************************************************************
535 This is a *horribly expensive call as we have to iterate through all the
536 current printer tdb's. Don't do this often ! JRA.
537 ****************************************************************************/
539 uint32
sysjob_to_jobid(int unix_jobid
)
541 int services
= lp_numservices();
543 struct unixjob_traverse_state state
;
545 state
.sysjob
= unix_jobid
;
546 state
.sysjob_to_jobid_value
= (uint32
)-1;
548 for (snum
= 0; snum
< services
; snum
++) {
549 struct tdb_print_db
*pdb
;
550 if (!lp_print_ok(snum
))
552 pdb
= get_print_db_byname(lp_const_servicename(snum
));
556 tdb_traverse(pdb
->tdb
, unixjob_traverse_fn
, &state
);
557 release_print_db(pdb
);
558 if (state
.sysjob_to_jobid_value
!= (uint32
)-1)
559 return state
.sysjob_to_jobid_value
;
564 /****************************************************************************
565 Send notifications based on what has changed after a pjob_store.
566 ****************************************************************************/
568 static const struct {
570 uint32_t spoolss_status
;
571 } lpq_to_spoolss_status_map
[] = {
572 { LPQ_QUEUED
, JOB_STATUS_QUEUED
},
573 { LPQ_PAUSED
, JOB_STATUS_PAUSED
},
574 { LPQ_SPOOLING
, JOB_STATUS_SPOOLING
},
575 { LPQ_PRINTING
, JOB_STATUS_PRINTING
},
576 { LPQ_DELETING
, JOB_STATUS_DELETING
},
577 { LPQ_OFFLINE
, JOB_STATUS_OFFLINE
},
578 { LPQ_PAPEROUT
, JOB_STATUS_PAPEROUT
},
579 { LPQ_PRINTED
, JOB_STATUS_PRINTED
},
580 { LPQ_DELETED
, JOB_STATUS_DELETED
},
581 { LPQ_BLOCKED
, JOB_STATUS_BLOCKED_DEVQ
},
582 { LPQ_USER_INTERVENTION
, JOB_STATUS_USER_INTERVENTION
},
586 /* Convert a lpq status value stored in printing.tdb into the
587 appropriate win32 API constant. */
589 static uint32
map_to_spoolss_status(uint32 lpq_status
)
593 while (lpq_to_spoolss_status_map
[i
].lpq_status
!= -1) {
594 if (lpq_to_spoolss_status_map
[i
].lpq_status
== lpq_status
)
595 return lpq_to_spoolss_status_map
[i
].spoolss_status
;
602 /***************************************************************************
603 Append a jobid to the 'jobs changed' list.
604 ***************************************************************************/
606 static bool add_to_jobs_changed(struct tdb_print_db
*pdb
, uint32_t jobid
)
609 uint32_t store_jobid
;
611 SIVAL(&store_jobid
, 0, jobid
);
612 data
.dptr
= (uint8
*) &store_jobid
;
615 DEBUG(10,("add_to_jobs_added: Added jobid %u\n", (unsigned int)jobid
));
617 return (tdb_append(pdb
->tdb
, string_tdb_data("INFO/jobs_changed"),
621 /***************************************************************************
622 Remove a jobid from the 'jobs changed' list.
623 ***************************************************************************/
625 static bool remove_from_jobs_changed(const char* sharename
, uint32_t jobid
)
627 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
631 bool gotlock
= False
;
639 key
= string_tdb_data("INFO/jobs_changed");
641 if (tdb_chainlock_with_timeout(pdb
->tdb
, key
, 5) != 0)
646 data
= tdb_fetch_compat(pdb
->tdb
, key
);
648 if (data
.dptr
== NULL
|| data
.dsize
== 0 || (data
.dsize
% 4 != 0))
651 job_count
= data
.dsize
/ 4;
652 for (i
= 0; i
< job_count
; i
++) {
655 ch_jobid
= IVAL(data
.dptr
, i
*4);
656 if (ch_jobid
== jobid
) {
657 if (i
< job_count
-1 )
658 memmove(data
.dptr
+ (i
*4), data
.dptr
+ (i
*4) + 4, (job_count
- i
- 1)*4 );
660 if (tdb_store(pdb
->tdb
, key
, data
, TDB_REPLACE
) != 0)
670 tdb_chainunlock(pdb
->tdb
, key
);
671 SAFE_FREE(data
.dptr
);
672 release_print_db(pdb
);
674 DEBUG(10,("remove_from_jobs_changed: removed jobid %u\n", (unsigned int)jobid
));
676 DEBUG(10,("remove_from_jobs_changed: Failed to remove jobid %u\n", (unsigned int)jobid
));
680 static void pjob_store_notify(struct tevent_context
*ev
,
681 struct messaging_context
*msg_ctx
,
682 const char* sharename
, uint32 jobid
,
683 struct printjob
*old_data
,
684 struct printjob
*new_data
,
687 bool new_job
= false;
688 bool changed
= false;
690 if (old_data
== NULL
) {
694 /* ACHTUNG! Due to a bug in Samba's spoolss parsing of the
695 NOTIFY_INFO_DATA buffer, we *have* to send the job submission
696 time first or else we'll end up with potential alignment
697 errors. I don't think the systemtime should be spooled as
698 a string, but this gets us around that error.
699 --jerry (i'll feel dirty for this) */
702 notify_job_submitted(ev
, msg_ctx
,
703 sharename
, jobid
, new_data
->starttime
);
704 notify_job_username(ev
, msg_ctx
,
705 sharename
, jobid
, new_data
->user
);
706 notify_job_name(ev
, msg_ctx
,
707 sharename
, jobid
, new_data
->jobname
);
708 notify_job_status(ev
, msg_ctx
,
709 sharename
, jobid
, map_to_spoolss_status(new_data
->status
));
710 notify_job_total_bytes(ev
, msg_ctx
,
711 sharename
, jobid
, new_data
->size
);
712 notify_job_total_pages(ev
, msg_ctx
,
713 sharename
, jobid
, new_data
->page_count
);
715 if (!strequal(old_data
->jobname
, new_data
->jobname
)) {
716 notify_job_name(ev
, msg_ctx
, sharename
,
717 jobid
, new_data
->jobname
);
721 if (old_data
->status
!= new_data
->status
) {
722 notify_job_status(ev
, msg_ctx
,
724 map_to_spoolss_status(new_data
->status
));
727 if (old_data
->size
!= new_data
->size
) {
728 notify_job_total_bytes(ev
, msg_ctx
,
729 sharename
, jobid
, new_data
->size
);
732 if (old_data
->page_count
!= new_data
->page_count
) {
733 notify_job_total_pages(ev
, msg_ctx
,
735 new_data
->page_count
);
742 /****************************************************************************
743 Store a job structure back to the database.
744 ****************************************************************************/
746 static bool pjob_store(struct tevent_context
*ev
,
747 struct messaging_context
*msg_ctx
,
748 const char* sharename
, uint32 jobid
,
749 struct printjob
*pjob
)
752 TDB_DATA old_data
, new_data
;
754 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
756 int len
, newlen
, buflen
;
764 old_data
= tdb_fetch_compat(pdb
->tdb
, print_key(jobid
, &tmp
));
766 /* Doh! Now we have to pack/unpack data since the NT_DEVICEMODE was added */
773 len
+= tdb_pack(buf
+len
, buflen
-len
, "ddddddddddfffff",
776 (uint32
)pjob
->sysjob
,
778 (uint32
)pjob
->starttime
,
779 (uint32
)pjob
->status
,
781 (uint32
)pjob
->page_count
,
782 (uint32
)pjob
->spooled
,
783 (uint32
)pjob
->smbjob
,
790 len
+= pack_devicemode(pjob
->devmode
, buf
+len
, buflen
-len
);
793 buf
= (uint8
*)SMB_REALLOC(buf
, len
);
795 DEBUG(0,("pjob_store: failed to enlarge buffer!\n"));
800 } while ( buflen
!= len
);
806 new_data
.dsize
= len
;
807 ret
= (tdb_store(pdb
->tdb
, print_key(jobid
, &tmp
), new_data
,
810 /* Send notify updates for what has changed */
813 bool changed
= false;
814 struct printjob old_pjob
;
816 if (old_data
.dsize
) {
817 TALLOC_CTX
*tmp_ctx
= talloc_new(ev
);
821 len
= unpack_pjob(tmp_ctx
, old_data
.dptr
,
822 old_data
.dsize
, &old_pjob
);
824 pjob_store_notify(ev
,
826 sharename
, jobid
, &old_pjob
,
830 add_to_jobs_changed(pdb
, jobid
);
833 talloc_free(tmp_ctx
);
837 pjob_store_notify(ev
, msg_ctx
,
838 sharename
, jobid
, NULL
, pjob
,
844 release_print_db(pdb
);
845 SAFE_FREE( old_data
.dptr
);
851 /****************************************************************************
852 Remove a job structure from the database.
853 ****************************************************************************/
855 static void pjob_delete(struct tevent_context
*ev
,
856 struct messaging_context
*msg_ctx
,
857 const char* sharename
, uint32 jobid
)
860 struct printjob
*pjob
;
861 uint32 job_status
= 0;
862 struct tdb_print_db
*pdb
;
863 TALLOC_CTX
*tmp_ctx
= talloc_new(ev
);
864 if (tmp_ctx
== NULL
) {
868 pdb
= get_print_db_byname(sharename
);
873 pjob
= print_job_find(tmp_ctx
, sharename
, jobid
);
875 DEBUG(5, ("we were asked to delete nonexistent job %u\n",
880 /* We must cycle through JOB_STATUS_DELETING and
881 JOB_STATUS_DELETED for the port monitor to delete the job
884 job_status
= JOB_STATUS_DELETING
|JOB_STATUS_DELETED
;
885 notify_job_status(ev
, msg_ctx
, sharename
, jobid
, job_status
);
887 /* Remove from printing.tdb */
889 tdb_delete(pdb
->tdb
, print_key(jobid
, &tmp
));
890 remove_from_jobs_added(sharename
, jobid
);
891 rap_jobid_delete(sharename
, jobid
);
893 release_print_db(pdb
);
895 talloc_free(tmp_ctx
);
898 /****************************************************************************
899 List a unix job in the print database.
900 ****************************************************************************/
902 static void print_unix_job(struct tevent_context
*ev
,
903 struct messaging_context
*msg_ctx
,
904 const char *sharename
, print_queue_struct
*q
,
907 struct printjob pj
, *old_pj
;
908 TALLOC_CTX
*tmp_ctx
= talloc_new(ev
);
909 if (tmp_ctx
== NULL
) {
913 if (jobid
== (uint32
)-1) {
914 jobid
= q
->sysjob
+ UNIX_JOB_START
;
917 /* Preserve the timestamp on an existing unix print job */
919 old_pj
= print_job_find(tmp_ctx
, sharename
, jobid
);
925 pj
.sysjob
= q
->sysjob
;
927 pj
.starttime
= old_pj
? old_pj
->starttime
: q
->time
;
928 pj
.status
= q
->status
;
931 fstrcpy(pj
.filename
, old_pj
? old_pj
->filename
: "");
932 if (jobid
< UNIX_JOB_START
) {
934 fstrcpy(pj
.jobname
, old_pj
? old_pj
->jobname
: "Remote Downlevel Document");
937 fstrcpy(pj
.jobname
, old_pj
? old_pj
->jobname
: q
->fs_file
);
939 fstrcpy(pj
.user
, old_pj
? old_pj
->user
: q
->fs_user
);
940 fstrcpy(pj
.queuename
, old_pj
? old_pj
->queuename
: sharename
);
942 pjob_store(ev
, msg_ctx
, sharename
, jobid
, &pj
);
943 talloc_free(tmp_ctx
);
947 struct traverse_struct
{
948 print_queue_struct
*queue
;
949 int qcount
, snum
, maxcount
, total_jobs
;
950 const char *sharename
;
952 const char *lprm_command
;
953 struct printif
*print_if
;
954 struct tevent_context
*ev
;
955 struct messaging_context
*msg_ctx
;
959 /****************************************************************************
960 Utility fn to delete any jobs that are no longer active.
961 ****************************************************************************/
963 static int traverse_fn_delete(TDB_CONTEXT
*t
, TDB_DATA key
, TDB_DATA data
, void *state
)
965 struct traverse_struct
*ts
= (struct traverse_struct
*)state
;
966 struct printjob pjob
;
970 if ( key
.dsize
!= sizeof(jobid
) )
973 if (unpack_pjob(ts
->mem_ctx
, data
.dptr
, data
.dsize
, &pjob
) == -1)
975 talloc_free(pjob
.devmode
);
979 /* remove a unix job if it isn't in the system queue any more */
980 for (i
=0;i
<ts
->qcount
;i
++) {
981 if (ts
->queue
[i
].sysjob
== pjob
.sysjob
) {
985 if (i
== ts
->qcount
) {
986 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !smbjob\n",
987 (unsigned int)jobid
));
988 pjob_delete(ts
->ev
, ts
->msg_ctx
,
989 ts
->sharename
, jobid
);
993 /* need to continue the the bottom of the function to
994 save the correct attributes */
997 /* maybe it hasn't been spooled yet */
999 /* if a job is not spooled and the process doesn't
1000 exist then kill it. This cleans up after smbd
1002 if (!process_exists_by_pid(pjob
.pid
)) {
1003 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !process_exists (%u)\n",
1004 (unsigned int)jobid
, (unsigned int)pjob
.pid
));
1005 pjob_delete(ts
->ev
, ts
->msg_ctx
,
1006 ts
->sharename
, jobid
);
1012 /* this check only makes sense for jobs submitted from Windows clients */
1015 for (i
=0;i
<ts
->qcount
;i
++) {
1016 if ( pjob
.status
== LPQ_DELETED
)
1019 if (ts
->queue
[i
].sysjob
== pjob
.sysjob
) {
1021 /* try to clean up any jobs that need to be deleted */
1023 if ( pjob
.status
== LPQ_DELETING
) {
1026 result
= (*(ts
->print_if
->job_delete
))(
1027 ts
->sharename
, ts
->lprm_command
, &pjob
);
1029 if ( result
!= 0 ) {
1030 /* if we can't delete, then reset the job status */
1031 pjob
.status
= LPQ_QUEUED
;
1032 pjob_store(ts
->ev
, ts
->msg_ctx
,
1033 ts
->sharename
, jobid
, &pjob
);
1036 /* if we deleted the job, the remove the tdb record */
1039 ts
->sharename
, jobid
);
1040 pjob
.status
= LPQ_DELETED
;
1050 /* The job isn't in the system queue - we have to assume it has
1051 completed, so delete the database entry. */
1053 if (i
== ts
->qcount
) {
1055 /* A race can occur between the time a job is spooled and
1056 when it appears in the lpq output. This happens when
1057 the job is added to printing.tdb when another smbd
1058 running print_queue_update() has completed a lpq and
1059 is currently traversing the printing tdb and deleting jobs.
1060 Don't delete the job if it was submitted after the lpq_time. */
1062 if (pjob
.starttime
< ts
->lpq_time
) {
1063 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to pjob.starttime (%u) < ts->lpq_time (%u)\n",
1064 (unsigned int)jobid
,
1065 (unsigned int)pjob
.starttime
,
1066 (unsigned int)ts
->lpq_time
));
1067 pjob_delete(ts
->ev
, ts
->msg_ctx
,
1068 ts
->sharename
, jobid
);
1074 /* Save the pjob attributes we will store. */
1075 ts
->queue
[i
].sysjob
= pjob
.sysjob
;
1076 ts
->queue
[i
].size
= pjob
.size
;
1077 ts
->queue
[i
].page_count
= pjob
.page_count
;
1078 ts
->queue
[i
].status
= pjob
.status
;
1079 ts
->queue
[i
].priority
= 1;
1080 ts
->queue
[i
].time
= pjob
.starttime
;
1081 fstrcpy(ts
->queue
[i
].fs_user
, pjob
.user
);
1082 fstrcpy(ts
->queue
[i
].fs_file
, pjob
.jobname
);
1089 /****************************************************************************
1090 Check if the print queue has been updated recently enough.
1091 ****************************************************************************/
1093 static void print_cache_flush(const char *sharename
)
1096 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1100 slprintf(key
, sizeof(key
)-1, "CACHE/%s", sharename
);
1101 tdb_store_int32(pdb
->tdb
, key
, -1);
1102 release_print_db(pdb
);
1105 /****************************************************************************
1106 Check if someone already thinks they are doing the update.
1107 ****************************************************************************/
1109 static pid_t
get_updating_pid(const char *sharename
)
1114 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1118 slprintf(keystr
, sizeof(keystr
)-1, "UPDATING/%s", sharename
);
1119 key
= string_tdb_data(keystr
);
1121 data
= tdb_fetch_compat(pdb
->tdb
, key
);
1122 release_print_db(pdb
);
1123 if (!data
.dptr
|| data
.dsize
!= sizeof(pid_t
)) {
1124 SAFE_FREE(data
.dptr
);
1128 updating_pid
= IVAL(data
.dptr
, 0);
1129 SAFE_FREE(data
.dptr
);
1131 if (process_exists_by_pid(updating_pid
))
1132 return updating_pid
;
1137 /****************************************************************************
1138 Set the fact that we're doing the update, or have finished doing the update
1140 ****************************************************************************/
1142 static void set_updating_pid(const fstring sharename
, bool updating
)
1147 pid_t updating_pid
= getpid();
1150 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1155 slprintf(keystr
, sizeof(keystr
)-1, "UPDATING/%s", sharename
);
1156 key
= string_tdb_data(keystr
);
1158 DEBUG(5, ("set_updating_pid: %s updating lpq cache for print share %s\n",
1159 updating
? "" : "not ",
1163 tdb_delete(pdb
->tdb
, key
);
1164 release_print_db(pdb
);
1168 SIVAL( buffer
, 0, updating_pid
);
1170 data
.dsize
= 4; /* we always assume this is a 4 byte value */
1172 tdb_store(pdb
->tdb
, key
, data
, TDB_REPLACE
);
1173 release_print_db(pdb
);
1176 /****************************************************************************
1177 Sort print jobs by submittal time.
1178 ****************************************************************************/
1180 static int printjob_comp(print_queue_struct
*j1
, print_queue_struct
*j2
)
1191 /* Sort on job start time */
1193 if (j1
->time
== j2
->time
)
1195 return (j1
->time
> j2
->time
) ? 1 : -1;
1198 /****************************************************************************
1199 Store the sorted queue representation for later portmon retrieval.
1201 ****************************************************************************/
1203 static void store_queue_struct(struct tdb_print_db
*pdb
, struct traverse_struct
*pts
)
1206 int max_reported_jobs
= lp_max_reported_jobs(pts
->snum
);
1207 print_queue_struct
*queue
= pts
->queue
;
1210 unsigned int qcount
;
1212 if (max_reported_jobs
&& (max_reported_jobs
< pts
->qcount
))
1213 pts
->qcount
= max_reported_jobs
;
1216 /* Work out the size. */
1218 data
.dsize
+= tdb_pack(NULL
, 0, "d", qcount
);
1220 for (i
= 0; i
< pts
->qcount
; i
++) {
1221 if ( queue
[i
].status
== LPQ_DELETED
)
1225 data
.dsize
+= tdb_pack(NULL
, 0, "ddddddff",
1226 (uint32
)queue
[i
].sysjob
,
1227 (uint32
)queue
[i
].size
,
1228 (uint32
)queue
[i
].page_count
,
1229 (uint32
)queue
[i
].status
,
1230 (uint32
)queue
[i
].priority
,
1231 (uint32
)queue
[i
].time
,
1236 if ((data
.dptr
= (uint8
*)SMB_MALLOC(data
.dsize
)) == NULL
)
1240 len
+= tdb_pack(data
.dptr
+ len
, data
.dsize
- len
, "d", qcount
);
1241 for (i
= 0; i
< pts
->qcount
; i
++) {
1242 if ( queue
[i
].status
== LPQ_DELETED
)
1245 len
+= tdb_pack(data
.dptr
+ len
, data
.dsize
- len
, "ddddddff",
1246 (uint32
)queue
[i
].sysjob
,
1247 (uint32
)queue
[i
].size
,
1248 (uint32
)queue
[i
].page_count
,
1249 (uint32
)queue
[i
].status
,
1250 (uint32
)queue
[i
].priority
,
1251 (uint32
)queue
[i
].time
,
1256 tdb_store(pdb
->tdb
, string_tdb_data("INFO/linear_queue_array"), data
,
1258 SAFE_FREE(data
.dptr
);
1262 static TDB_DATA
get_jobs_added_data(struct tdb_print_db
*pdb
)
1268 data
= tdb_fetch_compat(pdb
->tdb
, string_tdb_data("INFO/jobs_added"));
1269 if (data
.dptr
== NULL
|| data
.dsize
== 0 || (data
.dsize
% 4 != 0)) {
1270 SAFE_FREE(data
.dptr
);
1277 static void check_job_added(const char *sharename
, TDB_DATA data
, uint32 jobid
)
1280 unsigned int job_count
= data
.dsize
/ 4;
1282 for (i
= 0; i
< job_count
; i
++) {
1285 ch_jobid
= IVAL(data
.dptr
, i
*4);
1286 if (ch_jobid
== jobid
)
1287 remove_from_jobs_added(sharename
, jobid
);
1291 /****************************************************************************
1292 Check if the print queue has been updated recently enough.
1293 ****************************************************************************/
1295 static bool print_cache_expired(const char *sharename
, bool check_pending
)
1298 time_t last_qscan_time
, time_now
= time(NULL
);
1299 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1300 bool result
= False
;
1305 snprintf(key
, sizeof(key
), "CACHE/%s", sharename
);
1306 last_qscan_time
= (time_t)tdb_fetch_int32(pdb
->tdb
, key
);
1309 * Invalidate the queue for 3 reasons.
1310 * (1). last queue scan time == -1.
1311 * (2). Current time - last queue scan time > allowed cache time.
1312 * (3). last queue scan time > current time + MAX_CACHE_VALID_TIME (1 hour by default).
1313 * This last test picks up machines for which the clock has been moved
1314 * forward, an lpq scan done and then the clock moved back. Otherwise
1315 * that last lpq scan would stay around for a loooong loooong time... :-). JRA.
1318 if (last_qscan_time
== ((time_t)-1)
1319 || (time_now
- last_qscan_time
) >= lp_lpqcachetime()
1320 || last_qscan_time
> (time_now
+ MAX_CACHE_VALID_TIME
))
1323 time_t msg_pending_time
;
1325 DEBUG(4, ("print_cache_expired: cache expired for queue %s "
1326 "(last_qscan_time = %d, time now = %d, qcachetime = %d)\n",
1327 sharename
, (int)last_qscan_time
, (int)time_now
,
1328 (int)lp_lpqcachetime() ));
1330 /* check if another smbd has already sent a message to update the
1331 queue. Give the pending message one minute to clear and
1332 then send another message anyways. Make sure to check for
1333 clocks that have been run forward and then back again. */
1335 snprintf(key
, sizeof(key
), "MSG_PENDING/%s", sharename
);
1338 && tdb_fetch_uint32( pdb
->tdb
, key
, &u
)
1339 && (msg_pending_time
=u
) > 0
1340 && msg_pending_time
<= time_now
1341 && (time_now
- msg_pending_time
) < 60 )
1343 DEBUG(4,("print_cache_expired: message already pending for %s. Accepting cache\n",
1352 release_print_db(pdb
);
1356 /****************************************************************************
1357 main work for updating the lpq cache for a printer queue
1358 ****************************************************************************/
1360 static void print_queue_update_internal(struct tevent_context
*ev
,
1361 struct messaging_context
*msg_ctx
,
1362 const char *sharename
,
1363 struct printif
*current_printif
,
1364 char *lpq_command
, char *lprm_command
)
1367 print_queue_struct
*queue
= NULL
;
1368 print_status_struct status
;
1369 print_status_struct old_status
;
1370 struct printjob
*pjob
;
1371 struct traverse_struct tstruct
;
1374 fstring keystr
, cachestr
;
1375 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1376 TALLOC_CTX
*tmp_ctx
= talloc_new(ev
);
1378 if ((pdb
== NULL
) || (tmp_ctx
== NULL
)) {
1382 DEBUG(5,("print_queue_update_internal: printer = %s, type = %d, lpq command = [%s]\n",
1383 sharename
, current_printif
->type
, lpq_command
));
1386 * Update the cache time FIRST ! Stops others even
1387 * attempting to get the lock and doing this
1388 * if the lpq takes a long time.
1391 slprintf(cachestr
, sizeof(cachestr
)-1, "CACHE/%s", sharename
);
1392 tdb_store_int32(pdb
->tdb
, cachestr
, (int)time(NULL
));
1394 /* get the current queue using the appropriate interface */
1395 ZERO_STRUCT(status
);
1397 qcount
= (*(current_printif
->queue_get
))(sharename
,
1398 current_printif
->type
,
1399 lpq_command
, &queue
, &status
);
1401 DEBUG(3, ("print_queue_update_internal: %d job%s in queue for %s\n",
1402 qcount
, (qcount
!= 1) ? "s" : "", sharename
));
1404 /* Sort the queue by submission time otherwise they are displayed
1407 TYPESAFE_QSORT(queue
, qcount
, printjob_comp
);
1410 any job in the internal database that is marked as spooled
1411 and doesn't exist in the system queue is considered finished
1412 and removed from the database
1414 any job in the system database but not in the internal database
1415 is added as a unix job
1417 fill in any system job numbers as we go
1419 jcdata
= get_jobs_added_data(pdb
);
1421 for (i
=0; i
<qcount
; i
++) {
1422 uint32 jobid
= sysjob_to_jobid_pdb(pdb
, queue
[i
].sysjob
);
1423 if (jobid
== (uint32
)-1) {
1424 /* assume its a unix print job */
1425 print_unix_job(ev
, msg_ctx
,
1426 sharename
, &queue
[i
], jobid
);
1430 /* we have an active SMB print job - update its status */
1431 pjob
= print_job_find(tmp_ctx
, sharename
, jobid
);
1433 /* err, somethings wrong. Probably smbd was restarted
1434 with jobs in the queue. All we can do is treat them
1435 like unix jobs. Pity. */
1436 DEBUG(1, ("queued print job %d not found in jobs list, "
1437 "assuming unix job\n", jobid
));
1438 print_unix_job(ev
, msg_ctx
,
1439 sharename
, &queue
[i
], jobid
);
1443 /* don't reset the status on jobs to be deleted */
1445 if ( pjob
->status
!= LPQ_DELETING
)
1446 pjob
->status
= queue
[i
].status
;
1448 pjob_store(ev
, msg_ctx
, sharename
, jobid
, pjob
);
1450 check_job_added(sharename
, jcdata
, jobid
);
1453 SAFE_FREE(jcdata
.dptr
);
1455 /* now delete any queued entries that don't appear in the
1457 tstruct
.queue
= queue
;
1458 tstruct
.qcount
= qcount
;
1460 tstruct
.total_jobs
= 0;
1461 tstruct
.lpq_time
= time(NULL
);
1462 tstruct
.sharename
= sharename
;
1463 tstruct
.lprm_command
= lprm_command
;
1464 tstruct
.print_if
= current_printif
;
1466 tstruct
.msg_ctx
= msg_ctx
;
1467 tstruct
.mem_ctx
= tmp_ctx
;
1469 tdb_traverse(pdb
->tdb
, traverse_fn_delete
, (void *)&tstruct
);
1471 /* Store the linearised queue, max jobs only. */
1472 store_queue_struct(pdb
, &tstruct
);
1474 SAFE_FREE(tstruct
.queue
);
1475 talloc_free(tmp_ctx
);
1477 DEBUG(10,("print_queue_update_internal: printer %s INFO/total_jobs = %d\n",
1478 sharename
, tstruct
.total_jobs
));
1480 tdb_store_int32(pdb
->tdb
, "INFO/total_jobs", tstruct
.total_jobs
);
1482 get_queue_status(sharename
, &old_status
);
1483 if (old_status
.qcount
!= qcount
)
1484 DEBUG(10,("print_queue_update_internal: queue status change %d jobs -> %d jobs for printer %s\n",
1485 old_status
.qcount
, qcount
, sharename
));
1487 /* store the new queue status structure */
1488 slprintf(keystr
, sizeof(keystr
)-1, "STATUS/%s", sharename
);
1489 key
= string_tdb_data(keystr
);
1491 status
.qcount
= qcount
;
1492 data
.dptr
= (uint8
*)&status
;
1493 data
.dsize
= sizeof(status
);
1494 tdb_store(pdb
->tdb
, key
, data
, TDB_REPLACE
);
1497 * Update the cache time again. We want to do this call
1498 * as little as possible...
1501 slprintf(keystr
, sizeof(keystr
)-1, "CACHE/%s", sharename
);
1502 tdb_store_int32(pdb
->tdb
, keystr
, (int32
)time(NULL
));
1504 /* clear the msg pending record for this queue */
1506 snprintf(keystr
, sizeof(keystr
), "MSG_PENDING/%s", sharename
);
1508 if ( !tdb_store_uint32( pdb
->tdb
, keystr
, 0 ) ) {
1509 /* log a message but continue on */
1511 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1515 release_print_db( pdb
);
1520 /****************************************************************************
1521 Update the internal database from the system print queue for a queue.
1522 obtain a lock on the print queue before proceeding (needed when mutiple
1523 smbd processes maytry to update the lpq cache concurrently).
1524 ****************************************************************************/
1526 static void print_queue_update_with_lock( struct tevent_context
*ev
,
1527 struct messaging_context
*msg_ctx
,
1528 const char *sharename
,
1529 struct printif
*current_printif
,
1530 char *lpq_command
, char *lprm_command
)
1533 struct tdb_print_db
*pdb
;
1535 DEBUG(5,("print_queue_update_with_lock: printer share = %s\n", sharename
));
1536 pdb
= get_print_db_byname(sharename
);
1540 if ( !print_cache_expired(sharename
, False
) ) {
1541 DEBUG(5,("print_queue_update_with_lock: print cache for %s is still ok\n", sharename
));
1542 release_print_db(pdb
);
1547 * Check to see if someone else is doing this update.
1548 * This is essentially a mutex on the update.
1551 if (get_updating_pid(sharename
) != -1) {
1552 release_print_db(pdb
);
1556 /* Lock the queue for the database update */
1558 slprintf(keystr
, sizeof(keystr
) - 1, "LOCK/%s", sharename
);
1559 /* Only wait 10 seconds for this. */
1560 if (tdb_lock_bystring_with_timeout(pdb
->tdb
, keystr
, 10) != 0) {
1561 DEBUG(0,("print_queue_update_with_lock: Failed to lock printer %s database\n", sharename
));
1562 release_print_db(pdb
);
1567 * Ensure that no one else got in here.
1568 * If the updating pid is still -1 then we are
1572 if (get_updating_pid(sharename
) != -1) {
1574 * Someone else is doing the update, exit.
1576 tdb_unlock_bystring(pdb
->tdb
, keystr
);
1577 release_print_db(pdb
);
1582 * We're going to do the update ourselves.
1585 /* Tell others we're doing the update. */
1586 set_updating_pid(sharename
, True
);
1589 * Allow others to enter and notice we're doing
1593 tdb_unlock_bystring(pdb
->tdb
, keystr
);
1595 /* do the main work now */
1597 print_queue_update_internal(ev
, msg_ctx
,
1598 sharename
, current_printif
,
1599 lpq_command
, lprm_command
);
1601 /* Delete our pid from the db. */
1602 set_updating_pid(sharename
, False
);
1603 release_print_db(pdb
);
1606 /****************************************************************************
1607 this is the receive function of the background lpq updater
1608 ****************************************************************************/
1609 void print_queue_receive(struct messaging_context
*msg
,
1612 struct server_id server_id
,
1616 char *lpqcommand
= NULL
, *lprmcommand
= NULL
;
1620 len
= tdb_unpack( (uint8
*)data
->data
, data
->length
, "fdPP",
1627 SAFE_FREE(lpqcommand
);
1628 SAFE_FREE(lprmcommand
);
1629 DEBUG(0,("print_queue_receive: Got invalid print queue update message\n"));
1633 print_queue_update_with_lock(server_event_context(), msg
, sharename
,
1634 get_printer_fns_from_type((enum printing_types
)printing_type
),
1635 lpqcommand
, lprmcommand
);
1637 SAFE_FREE(lpqcommand
);
1638 SAFE_FREE(lprmcommand
);
1642 /****************************************************************************
1643 update the internal database from the system print queue for a queue
1644 ****************************************************************************/
1646 extern pid_t background_lpq_updater_pid
;
1648 static void print_queue_update(struct messaging_context
*msg_ctx
,
1649 int snum
, bool force
)
1653 char *lpqcommand
= NULL
;
1654 char *lprmcommand
= NULL
;
1655 uint8
*buffer
= NULL
;
1658 struct tdb_print_db
*pdb
;
1660 struct printif
*current_printif
;
1661 TALLOC_CTX
*ctx
= talloc_tos();
1663 fstrcpy( sharename
, lp_const_servicename(snum
));
1665 /* don't strip out characters like '$' from the printername */
1667 lpqcommand
= talloc_string_sub2(ctx
,
1668 lp_lpqcommand(talloc_tos(), snum
),
1670 lp_printername(talloc_tos(), snum
),
1671 false, false, false);
1675 lpqcommand
= talloc_sub_advanced(ctx
,
1676 lp_servicename(talloc_tos(), snum
),
1677 current_user_info
.unix_name
,
1679 current_user
.ut
.gid
,
1680 get_current_username(),
1681 current_user_info
.domain
,
1687 lprmcommand
= talloc_string_sub2(ctx
,
1688 lp_lprmcommand(talloc_tos(), snum
),
1690 lp_printername(talloc_tos(), snum
),
1691 false, false, false);
1695 lprmcommand
= talloc_sub_advanced(ctx
,
1696 lp_servicename(talloc_tos(), snum
),
1697 current_user_info
.unix_name
,
1699 current_user
.ut
.gid
,
1700 get_current_username(),
1701 current_user_info
.domain
,
1708 * Make sure that the background queue process exists.
1709 * Otherwise just do the update ourselves
1712 if ( force
|| background_lpq_updater_pid
== -1 ) {
1713 DEBUG(4,("print_queue_update: updating queue [%s] myself\n", sharename
));
1714 current_printif
= get_printer_fns( snum
);
1715 print_queue_update_with_lock(server_event_context(), msg_ctx
,
1716 sharename
, current_printif
,
1717 lpqcommand
, lprmcommand
);
1722 type
= lp_printing(snum
);
1724 /* get the length */
1726 len
= tdb_pack( NULL
, 0, "fdPP",
1732 buffer
= SMB_XMALLOC_ARRAY( uint8
, len
);
1734 /* now pack the buffer */
1735 newlen
= tdb_pack( buffer
, len
, "fdPP",
1741 SMB_ASSERT( newlen
== len
);
1743 DEBUG(10,("print_queue_update: Sending message -> printer = %s, "
1744 "type = %d, lpq command = [%s] lprm command = [%s]\n",
1745 sharename
, type
, lpqcommand
, lprmcommand
));
1747 /* here we set a msg pending record for other smbd processes
1748 to throttle the number of duplicate print_queue_update msgs
1751 pdb
= get_print_db_byname(sharename
);
1757 snprintf(key
, sizeof(key
), "MSG_PENDING/%s", sharename
);
1759 if ( !tdb_store_uint32( pdb
->tdb
, key
, time(NULL
) ) ) {
1760 /* log a message but continue on */
1762 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1766 release_print_db( pdb
);
1768 /* finally send the message */
1770 messaging_send_buf(msg_ctx
, pid_to_procid(background_lpq_updater_pid
),
1771 MSG_PRINTER_UPDATE
, (uint8
*)buffer
, len
);
1773 SAFE_FREE( buffer
);
1778 /****************************************************************************
1779 Create/Update an entry in the print tdb that will allow us to send notify
1780 updates only to interested smbd's.
1781 ****************************************************************************/
1783 bool print_notify_register_pid(int snum
)
1786 struct tdb_print_db
*pdb
= NULL
;
1787 TDB_CONTEXT
*tdb
= NULL
;
1788 const char *printername
;
1789 uint32_t mypid
= (uint32_t)getpid();
1793 /* if (snum == -1), then the change notify request was
1794 on a print server handle and we need to register on
1799 int num_services
= lp_numservices();
1802 for ( idx
=0; idx
<num_services
; idx
++ ) {
1803 if (lp_snum_ok(idx
) && lp_print_ok(idx
) )
1804 print_notify_register_pid(idx
);
1809 else /* register for a specific printer */
1811 printername
= lp_const_servicename(snum
);
1812 pdb
= get_print_db_byname(printername
);
1818 if (tdb_lock_bystring_with_timeout(tdb
, NOTIFY_PID_LIST_KEY
, 10) != 0) {
1819 DEBUG(0,("print_notify_register_pid: Failed to lock printer %s\n",
1822 release_print_db(pdb
);
1826 data
= get_printer_notify_pid_list( tdb
, printername
, True
);
1828 /* Add ourselves and increase the refcount. */
1830 for (i
= 0; i
< data
.dsize
; i
+= 8) {
1831 if (IVAL(data
.dptr
,i
) == mypid
) {
1832 uint32 new_refcount
= IVAL(data
.dptr
, i
+4) + 1;
1833 SIVAL(data
.dptr
, i
+4, new_refcount
);
1838 if (i
== data
.dsize
) {
1839 /* We weren't in the list. Realloc. */
1840 data
.dptr
= (uint8
*)SMB_REALLOC(data
.dptr
, data
.dsize
+ 8);
1842 DEBUG(0,("print_notify_register_pid: Relloc fail for printer %s\n",
1847 SIVAL(data
.dptr
,data
.dsize
- 8,mypid
);
1848 SIVAL(data
.dptr
,data
.dsize
- 4,1); /* Refcount. */
1851 /* Store back the record. */
1852 if (tdb_store_bystring(tdb
, NOTIFY_PID_LIST_KEY
, data
, TDB_REPLACE
) != 0) {
1853 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1854 list for printer %s\n", printername
));
1862 tdb_unlock_bystring(tdb
, NOTIFY_PID_LIST_KEY
);
1864 release_print_db(pdb
);
1865 SAFE_FREE(data
.dptr
);
1869 /****************************************************************************
1870 Update an entry in the print tdb that will allow us to send notify
1871 updates only to interested smbd's.
1872 ****************************************************************************/
1874 bool print_notify_deregister_pid(int snum
)
1877 struct tdb_print_db
*pdb
= NULL
;
1878 TDB_CONTEXT
*tdb
= NULL
;
1879 const char *printername
;
1880 uint32_t mypid
= (uint32_t)getpid();
1884 /* if ( snum == -1 ), we are deregister a print server handle
1885 which means to deregister on all print queues */
1889 int num_services
= lp_numservices();
1892 for ( idx
=0; idx
<num_services
; idx
++ ) {
1893 if ( lp_snum_ok(idx
) && lp_print_ok(idx
) )
1894 print_notify_deregister_pid(idx
);
1899 else /* deregister a specific printer */
1901 printername
= lp_const_servicename(snum
);
1902 pdb
= get_print_db_byname(printername
);
1908 if (tdb_lock_bystring_with_timeout(tdb
, NOTIFY_PID_LIST_KEY
, 10) != 0) {
1909 DEBUG(0,("print_notify_register_pid: Failed to lock \
1910 printer %s database\n", printername
));
1912 release_print_db(pdb
);
1916 data
= get_printer_notify_pid_list( tdb
, printername
, True
);
1918 /* Reduce refcount. Remove ourselves if zero. */
1920 for (i
= 0; i
< data
.dsize
; ) {
1921 if (IVAL(data
.dptr
,i
) == mypid
) {
1922 uint32 refcount
= IVAL(data
.dptr
, i
+4);
1926 if (refcount
== 0) {
1927 if (data
.dsize
- i
> 8)
1928 memmove( &data
.dptr
[i
], &data
.dptr
[i
+8], data
.dsize
- i
- 8);
1932 SIVAL(data
.dptr
, i
+4, refcount
);
1938 if (data
.dsize
== 0)
1939 SAFE_FREE(data
.dptr
);
1941 /* Store back the record. */
1942 if (tdb_store_bystring(tdb
, NOTIFY_PID_LIST_KEY
, data
, TDB_REPLACE
) != 0) {
1943 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1944 list for printer %s\n", printername
));
1952 tdb_unlock_bystring(tdb
, NOTIFY_PID_LIST_KEY
);
1954 release_print_db(pdb
);
1955 SAFE_FREE(data
.dptr
);
1959 /****************************************************************************
1960 Check if a jobid is valid. It is valid if it exists in the database.
1961 ****************************************************************************/
1963 bool print_job_exists(const char* sharename
, uint32 jobid
)
1965 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1971 ret
= tdb_exists(pdb
->tdb
, print_key(jobid
, &tmp
));
1972 release_print_db(pdb
);
1976 /****************************************************************************
1977 Return the device mode asigned to a specific print job.
1978 Only valid for the process doing the spooling and when the job
1979 has not been spooled.
1980 ****************************************************************************/
1982 struct spoolss_DeviceMode
*print_job_devmode(TALLOC_CTX
*mem_ctx
,
1983 const char *sharename
,
1986 struct printjob
*pjob
= print_job_find(mem_ctx
, sharename
, jobid
);
1991 return pjob
->devmode
;
1994 /****************************************************************************
1995 Set the name of a job. Only possible for owner.
1996 ****************************************************************************/
1998 bool print_job_set_name(struct tevent_context
*ev
,
1999 struct messaging_context
*msg_ctx
,
2000 const char *sharename
, uint32 jobid
, const char *name
)
2002 struct printjob
*pjob
;
2004 TALLOC_CTX
*tmp_ctx
= talloc_new(ev
);
2005 if (tmp_ctx
== NULL
) {
2009 pjob
= print_job_find(tmp_ctx
, sharename
, jobid
);
2010 if (!pjob
|| pjob
->pid
!= getpid()) {
2015 fstrcpy(pjob
->jobname
, name
);
2016 ret
= pjob_store(ev
, msg_ctx
, sharename
, jobid
, pjob
);
2018 talloc_free(tmp_ctx
);
2022 /****************************************************************************
2023 Get the name of a job. Only possible for owner.
2024 ****************************************************************************/
2026 bool print_job_get_name(TALLOC_CTX
*mem_ctx
, const char *sharename
, uint32_t jobid
, char **name
)
2028 struct printjob
*pjob
;
2030 pjob
= print_job_find(mem_ctx
, sharename
, jobid
);
2031 if (!pjob
|| pjob
->pid
!= getpid()) {
2035 *name
= pjob
->jobname
;
2040 /***************************************************************************
2041 Remove a jobid from the 'jobs added' list.
2042 ***************************************************************************/
2044 static bool remove_from_jobs_added(const char* sharename
, uint32 jobid
)
2046 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
2048 size_t job_count
, i
;
2050 bool gotlock
= False
;
2058 key
= string_tdb_data("INFO/jobs_added");
2060 if (tdb_chainlock_with_timeout(pdb
->tdb
, key
, 5) != 0)
2065 data
= tdb_fetch_compat(pdb
->tdb
, key
);
2067 if (data
.dptr
== NULL
|| data
.dsize
== 0 || (data
.dsize
% 4 != 0))
2070 job_count
= data
.dsize
/ 4;
2071 for (i
= 0; i
< job_count
; i
++) {
2074 ch_jobid
= IVAL(data
.dptr
, i
*4);
2075 if (ch_jobid
== jobid
) {
2076 if (i
< job_count
-1 )
2077 memmove(data
.dptr
+ (i
*4), data
.dptr
+ (i
*4) + 4, (job_count
- i
- 1)*4 );
2079 if (tdb_store(pdb
->tdb
, key
, data
, TDB_REPLACE
) != 0)
2089 tdb_chainunlock(pdb
->tdb
, key
);
2090 SAFE_FREE(data
.dptr
);
2091 release_print_db(pdb
);
2093 DEBUG(10,("remove_from_jobs_added: removed jobid %u\n", (unsigned int)jobid
));
2095 DEBUG(10,("remove_from_jobs_added: Failed to remove jobid %u\n", (unsigned int)jobid
));
2099 /****************************************************************************
2100 Delete a print job - don't update queue.
2101 ****************************************************************************/
2103 static bool print_job_delete1(struct tevent_context
*ev
,
2104 struct messaging_context
*msg_ctx
,
2105 int snum
, uint32 jobid
)
2107 const char* sharename
= lp_const_servicename(snum
);
2108 struct printjob
*pjob
;
2110 struct printif
*current_printif
= get_printer_fns( snum
);
2112 TALLOC_CTX
*tmp_ctx
= talloc_new(ev
);
2113 if (tmp_ctx
== NULL
) {
2117 pjob
= print_job_find(tmp_ctx
, sharename
, jobid
);
2124 * If already deleting just return.
2127 if (pjob
->status
== LPQ_DELETING
) {
2132 /* Hrm - we need to be able to cope with deleting a job before it
2133 has reached the spooler. Just mark it as LPQ_DELETING and
2134 let the print_queue_update() code rmeove the record */
2137 if (pjob
->sysjob
== -1) {
2138 DEBUG(5, ("attempt to delete job %u not seen by lpr\n", (unsigned int)jobid
));
2141 /* Set the tdb entry to be deleting. */
2143 pjob
->status
= LPQ_DELETING
;
2144 pjob_store(ev
, msg_ctx
, sharename
, jobid
, pjob
);
2146 if (pjob
->spooled
&& pjob
->sysjob
!= -1)
2148 result
= (*(current_printif
->job_delete
))(
2149 lp_printername(talloc_tos(), snum
),
2150 lp_lprmcommand(talloc_tos(), snum
),
2153 /* Delete the tdb entry if the delete succeeded or the job hasn't
2157 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
2164 pjob_delete(ev
, msg_ctx
, sharename
, jobid
);
2165 /* Ensure we keep a rough count of the number of total jobs... */
2166 tdb_change_int32_atomic(pdb
->tdb
, "INFO/total_jobs", &njobs
, -1);
2167 release_print_db(pdb
);
2171 remove_from_jobs_added( sharename
, jobid
);
2173 ret
= (result
== 0);
2175 talloc_free(tmp_ctx
);
2179 /****************************************************************************
2180 Return true if the current user owns the print job.
2181 ****************************************************************************/
2183 static bool is_owner(const struct auth_session_info
*server_info
,
2184 const char *servicename
,
2187 struct printjob
*pjob
;
2189 TALLOC_CTX
*tmp_ctx
= talloc_new(server_info
);
2190 if (tmp_ctx
== NULL
) {
2194 pjob
= print_job_find(tmp_ctx
, servicename
, jobid
);
2195 if (!pjob
|| !server_info
) {
2200 ret
= strequal(pjob
->user
, server_info
->unix_info
->sanitized_username
);
2202 talloc_free(tmp_ctx
);
2206 /****************************************************************************
2208 ****************************************************************************/
2210 WERROR
print_job_delete(const struct auth_session_info
*server_info
,
2211 struct messaging_context
*msg_ctx
,
2212 int snum
, uint32_t jobid
)
2214 const char* sharename
= lp_const_servicename(snum
);
2215 struct printjob
*pjob
;
2218 TALLOC_CTX
*tmp_ctx
= talloc_new(msg_ctx
);
2219 if (tmp_ctx
== NULL
) {
2220 return WERR_NOT_ENOUGH_MEMORY
;
2223 owner
= is_owner(server_info
, lp_const_servicename(snum
), jobid
);
2225 /* Check access against security descriptor or whether the user
2229 !print_access_check(server_info
, msg_ctx
, snum
,
2230 JOB_ACCESS_ADMINISTER
)) {
2231 DEBUG(3, ("delete denied by security descriptor\n"));
2233 /* BEGIN_ADMIN_LOG */
2234 sys_adminlog( LOG_ERR
,
2235 "Permission denied-- user not allowed to delete, \
2236 pause, or resume print job. User name: %s. Printer name: %s.",
2237 uidtoname(server_info
->unix_token
->uid
),
2238 lp_printername(talloc_tos(), snum
) );
2241 werr
= WERR_ACCESS_DENIED
;
2246 * get the spooled filename of the print job
2247 * if this works, then the file has not been spooled
2248 * to the underlying print system. Just delete the
2249 * spool file & return.
2252 pjob
= print_job_find(tmp_ctx
, sharename
, jobid
);
2253 if (!pjob
|| pjob
->spooled
|| pjob
->pid
!= getpid()) {
2254 DEBUG(10, ("Skipping spool file removal for job %u\n", jobid
));
2256 DEBUG(10, ("Removing spool file [%s]\n", pjob
->filename
));
2257 if (unlink(pjob
->filename
) == -1) {
2258 werr
= map_werror_from_unix(errno
);
2263 if (!print_job_delete1(server_event_context(), msg_ctx
, snum
, jobid
)) {
2264 werr
= WERR_ACCESS_DENIED
;
2268 /* force update the database and say the delete failed if the
2271 print_queue_update(msg_ctx
, snum
, True
);
2273 pjob
= print_job_find(tmp_ctx
, sharename
, jobid
);
2274 if (pjob
&& (pjob
->status
!= LPQ_DELETING
)) {
2275 werr
= WERR_ACCESS_DENIED
;
2278 werr
= WERR_PRINTER_HAS_JOBS_QUEUED
;
2281 talloc_free(tmp_ctx
);
2285 /****************************************************************************
2287 ****************************************************************************/
2289 WERROR
print_job_pause(const struct auth_session_info
*server_info
,
2290 struct messaging_context
*msg_ctx
,
2291 int snum
, uint32 jobid
)
2293 const char* sharename
= lp_const_servicename(snum
);
2294 struct printjob
*pjob
;
2296 struct printif
*current_printif
= get_printer_fns( snum
);
2298 TALLOC_CTX
*tmp_ctx
= talloc_new(msg_ctx
);
2299 if (tmp_ctx
== NULL
) {
2300 return WERR_NOT_ENOUGH_MEMORY
;
2303 pjob
= print_job_find(tmp_ctx
, sharename
, jobid
);
2304 if (!pjob
|| !server_info
) {
2305 DEBUG(10, ("print_job_pause: no pjob or user for jobid %u\n",
2306 (unsigned int)jobid
));
2307 werr
= WERR_INVALID_PARAM
;
2311 if (!pjob
->spooled
|| pjob
->sysjob
== -1) {
2312 DEBUG(10, ("print_job_pause: not spooled or bad sysjob = %d for jobid %u\n",
2313 (int)pjob
->sysjob
, (unsigned int)jobid
));
2314 werr
= WERR_INVALID_PARAM
;
2318 if (!is_owner(server_info
, lp_const_servicename(snum
), jobid
) &&
2319 !print_access_check(server_info
, msg_ctx
, snum
,
2320 JOB_ACCESS_ADMINISTER
)) {
2321 DEBUG(3, ("pause denied by security descriptor\n"));
2323 /* BEGIN_ADMIN_LOG */
2324 sys_adminlog( LOG_ERR
,
2325 "Permission denied-- user not allowed to delete, \
2326 pause, or resume print job. User name: %s. Printer name: %s.",
2327 uidtoname(server_info
->unix_token
->uid
),
2328 lp_printername(talloc_tos(), snum
) );
2331 werr
= WERR_ACCESS_DENIED
;
2335 /* need to pause the spooled entry */
2336 ret
= (*(current_printif
->job_pause
))(snum
, pjob
);
2339 werr
= WERR_INVALID_PARAM
;
2343 /* force update the database */
2344 print_cache_flush(lp_const_servicename(snum
));
2346 /* Send a printer notify message */
2348 notify_job_status(server_event_context(), msg_ctx
, sharename
, jobid
,
2351 /* how do we tell if this succeeded? */
2354 talloc_free(tmp_ctx
);
2358 /****************************************************************************
2360 ****************************************************************************/
2362 WERROR
print_job_resume(const struct auth_session_info
*server_info
,
2363 struct messaging_context
*msg_ctx
,
2364 int snum
, uint32 jobid
)
2366 const char *sharename
= lp_const_servicename(snum
);
2367 struct printjob
*pjob
;
2369 struct printif
*current_printif
= get_printer_fns( snum
);
2371 TALLOC_CTX
*tmp_ctx
= talloc_new(msg_ctx
);
2372 if (tmp_ctx
== NULL
)
2373 return WERR_NOT_ENOUGH_MEMORY
;
2375 pjob
= print_job_find(tmp_ctx
, sharename
, jobid
);
2376 if (!pjob
|| !server_info
) {
2377 DEBUG(10, ("print_job_resume: no pjob or user for jobid %u\n",
2378 (unsigned int)jobid
));
2379 werr
= WERR_INVALID_PARAM
;
2383 if (!pjob
->spooled
|| pjob
->sysjob
== -1) {
2384 DEBUG(10, ("print_job_resume: not spooled or bad sysjob = %d for jobid %u\n",
2385 (int)pjob
->sysjob
, (unsigned int)jobid
));
2386 werr
= WERR_INVALID_PARAM
;
2390 if (!is_owner(server_info
, lp_const_servicename(snum
), jobid
) &&
2391 !print_access_check(server_info
, msg_ctx
, snum
,
2392 JOB_ACCESS_ADMINISTER
)) {
2393 DEBUG(3, ("resume denied by security descriptor\n"));
2395 /* BEGIN_ADMIN_LOG */
2396 sys_adminlog( LOG_ERR
,
2397 "Permission denied-- user not allowed to delete, \
2398 pause, or resume print job. User name: %s. Printer name: %s.",
2399 uidtoname(server_info
->unix_token
->uid
),
2400 lp_printername(talloc_tos(), snum
) );
2402 werr
= WERR_ACCESS_DENIED
;
2406 ret
= (*(current_printif
->job_resume
))(snum
, pjob
);
2409 werr
= WERR_INVALID_PARAM
;
2413 /* force update the database */
2414 print_cache_flush(lp_const_servicename(snum
));
2416 /* Send a printer notify message */
2418 notify_job_status(server_event_context(), msg_ctx
, sharename
, jobid
,
2423 talloc_free(tmp_ctx
);
2427 /****************************************************************************
2428 Write to a print file.
2429 ****************************************************************************/
2431 ssize_t
print_job_write(struct tevent_context
*ev
,
2432 struct messaging_context
*msg_ctx
,
2433 int snum
, uint32 jobid
, const char *buf
, size_t size
)
2435 const char* sharename
= lp_const_servicename(snum
);
2436 ssize_t return_code
;
2437 struct printjob
*pjob
;
2438 TALLOC_CTX
*tmp_ctx
= talloc_new(ev
);
2439 if (tmp_ctx
== NULL
) {
2443 pjob
= print_job_find(tmp_ctx
, sharename
, jobid
);
2449 /* don't allow another process to get this info - it is meaningless */
2450 if (pjob
->pid
!= getpid()) {
2455 /* if SMBD is spooling this can't be allowed */
2456 if (pjob
->status
== PJOB_SMBD_SPOOLING
) {
2461 return_code
= write_data(pjob
->fd
, buf
, size
);
2462 if (return_code
> 0) {
2464 pjob_store(ev
, msg_ctx
, sharename
, jobid
, pjob
);
2467 talloc_free(tmp_ctx
);
2471 /****************************************************************************
2472 Get the queue status - do not update if db is out of date.
2473 ****************************************************************************/
2475 static int get_queue_status(const char* sharename
, print_status_struct
*status
)
2479 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
2483 ZERO_STRUCTP(status
);
2490 fstr_sprintf(keystr
, "STATUS/%s", sharename
);
2491 data
= tdb_fetch_compat(pdb
->tdb
, string_tdb_data(keystr
));
2493 if (data
.dsize
== sizeof(print_status_struct
))
2494 /* this memcpy is ok since the status struct was
2495 not packed before storing it in the tdb */
2496 memcpy(status
, data
.dptr
, sizeof(print_status_struct
));
2497 SAFE_FREE(data
.dptr
);
2500 len
= tdb_fetch_int32(pdb
->tdb
, "INFO/total_jobs");
2501 release_print_db(pdb
);
2502 return (len
== -1 ? 0 : len
);
2505 /****************************************************************************
2506 Determine the number of jobs in a queue.
2507 ****************************************************************************/
2509 int print_queue_length(struct messaging_context
*msg_ctx
, int snum
,
2510 print_status_struct
*pstatus
)
2512 const char* sharename
= lp_const_servicename( snum
);
2513 print_status_struct status
;
2516 ZERO_STRUCT( status
);
2518 /* make sure the database is up to date */
2519 if (print_cache_expired(lp_const_servicename(snum
), True
))
2520 print_queue_update(msg_ctx
, snum
, False
);
2522 /* also fetch the queue status */
2523 memset(&status
, 0, sizeof(status
));
2524 len
= get_queue_status(sharename
, &status
);
2532 /***************************************************************************
2533 Allocate a jobid. Hold the lock for as short a time as possible.
2534 ***************************************************************************/
2536 static WERROR
allocate_print_jobid(struct tdb_print_db
*pdb
, int snum
,
2537 const char *sharename
, uint32
*pjobid
)
2541 enum TDB_ERROR terr
;
2544 *pjobid
= (uint32
)-1;
2546 for (i
= 0; i
< 3; i
++) {
2547 /* Lock the database - only wait 20 seconds. */
2548 ret
= tdb_lock_bystring_with_timeout(pdb
->tdb
,
2549 "INFO/nextjob", 20);
2551 DEBUG(0, ("allocate_print_jobid: "
2552 "Failed to lock printing database %s\n",
2554 terr
= tdb_error(pdb
->tdb
);
2555 return ntstatus_to_werror(map_nt_error_from_tdb(terr
));
2558 if (!tdb_fetch_uint32(pdb
->tdb
, "INFO/nextjob", &jobid
)) {
2559 terr
= tdb_error(pdb
->tdb
);
2560 if (terr
!= TDB_ERR_NOEXIST
) {
2561 DEBUG(0, ("allocate_print_jobid: "
2562 "Failed to fetch INFO/nextjob "
2563 "for print queue %s\n", sharename
));
2564 tdb_unlock_bystring(pdb
->tdb
, "INFO/nextjob");
2565 return ntstatus_to_werror(map_nt_error_from_tdb(terr
));
2567 DEBUG(10, ("allocate_print_jobid: "
2568 "No existing jobid in %s\n", sharename
));
2572 DEBUG(10, ("allocate_print_jobid: "
2573 "Read jobid %u from %s\n", jobid
, sharename
));
2575 jobid
= NEXT_JOBID(jobid
);
2577 ret
= tdb_store_int32(pdb
->tdb
, "INFO/nextjob", jobid
);
2579 terr
= tdb_error(pdb
->tdb
);
2580 DEBUG(3, ("allocate_print_jobid: "
2581 "Failed to store INFO/nextjob.\n"));
2582 tdb_unlock_bystring(pdb
->tdb
, "INFO/nextjob");
2583 return ntstatus_to_werror(map_nt_error_from_tdb(terr
));
2586 /* We've finished with the INFO/nextjob lock. */
2587 tdb_unlock_bystring(pdb
->tdb
, "INFO/nextjob");
2589 if (!print_job_exists(sharename
, jobid
)) {
2592 DEBUG(10, ("allocate_print_jobid: "
2593 "Found jobid %u in %s\n", jobid
, sharename
));
2597 DEBUG(0, ("allocate_print_jobid: "
2598 "Failed to allocate a print job for queue %s\n",
2600 /* Probably full... */
2601 return WERR_NO_SPOOL_SPACE
;
2604 /* Store a dummy placeholder. */
2610 if (tdb_store(pdb
->tdb
, print_key(jobid
, &tmp
), dum
,
2612 DEBUG(3, ("allocate_print_jobid: "
2613 "jobid (%d) failed to store placeholder.\n",
2615 terr
= tdb_error(pdb
->tdb
);
2616 return ntstatus_to_werror(map_nt_error_from_tdb(terr
));
2624 /***************************************************************************
2625 Append a jobid to the 'jobs added' list.
2626 ***************************************************************************/
2628 static bool add_to_jobs_added(struct tdb_print_db
*pdb
, uint32 jobid
)
2633 SIVAL(&store_jobid
, 0, jobid
);
2634 data
.dptr
= (uint8
*)&store_jobid
;
2637 DEBUG(10,("add_to_jobs_added: Added jobid %u\n", (unsigned int)jobid
));
2639 return (tdb_append(pdb
->tdb
, string_tdb_data("INFO/jobs_added"),
2644 /***************************************************************************
2645 Do all checks needed to determine if we can start a job.
2646 ***************************************************************************/
2648 static WERROR
print_job_checks(const struct auth_session_info
*server_info
,
2649 struct messaging_context
*msg_ctx
,
2650 int snum
, int *njobs
)
2652 const char *sharename
= lp_const_servicename(snum
);
2653 uint64_t dspace
, dsize
;
2657 if (!print_access_check(server_info
, msg_ctx
, snum
,
2658 PRINTER_ACCESS_USE
)) {
2659 DEBUG(3, ("print_job_checks: "
2660 "job start denied by security descriptor\n"));
2661 return WERR_ACCESS_DENIED
;
2664 if (!print_time_access_check(server_info
, msg_ctx
, sharename
)) {
2665 DEBUG(3, ("print_job_checks: "
2666 "job start denied by time check\n"));
2667 return WERR_ACCESS_DENIED
;
2670 /* see if we have sufficient disk space */
2671 if (lp_minprintspace(snum
)) {
2672 minspace
= lp_minprintspace(snum
);
2673 ret
= sys_fsusage(lp_pathname(talloc_tos(), snum
), &dspace
, &dsize
);
2674 if (ret
== 0 && dspace
< 2*minspace
) {
2675 DEBUG(3, ("print_job_checks: "
2676 "disk space check failed.\n"));
2677 return WERR_NO_SPOOL_SPACE
;
2681 /* for autoloaded printers, check that the printcap entry still exists */
2682 if (lp_autoloaded(snum
) && !pcap_printername_ok(sharename
)) {
2683 DEBUG(3, ("print_job_checks: printer name %s check failed.\n",
2685 return WERR_ACCESS_DENIED
;
2688 /* Insure the maximum queue size is not violated */
2689 *njobs
= print_queue_length(msg_ctx
, snum
, NULL
);
2690 if (*njobs
> lp_maxprintjobs(snum
)) {
2691 DEBUG(3, ("print_job_checks: Queue %s number of jobs (%d) "
2692 "larger than max printjobs per queue (%d).\n",
2693 sharename
, *njobs
, lp_maxprintjobs(snum
)));
2694 return WERR_NO_SPOOL_SPACE
;
2700 /***************************************************************************
2702 ***************************************************************************/
2704 static WERROR
print_job_spool_file(int snum
, uint32_t jobid
,
2705 const char *output_file
,
2706 struct printjob
*pjob
)
2714 /* if this file is within the printer path, it means that smbd
2715 * is spooling it and will pass us control when it is finished.
2716 * Verify that the file name is ok, within path, and it is
2717 * already already there */
2719 path
= lp_pathname(talloc_tos(), snum
);
2721 if (strncmp(output_file
, path
, len
) == 0 &&
2722 (output_file
[len
- 1] == '/' || output_file
[len
] == '/')) {
2724 /* verify path is not too long */
2725 if (strlen(output_file
) >= sizeof(pjob
->filename
)) {
2726 return WERR_INVALID_NAME
;
2729 /* verify that the file exists */
2730 if (sys_stat(output_file
, &st
, false) != 0) {
2731 return WERR_INVALID_NAME
;
2734 fstrcpy(pjob
->filename
, output_file
);
2736 DEBUG(3, ("print_job_spool_file:"
2737 "External spooling activated\n"));
2739 /* we do not open the file until spooling is done */
2741 pjob
->status
= PJOB_SMBD_SPOOLING
;
2747 slprintf(pjob
->filename
, sizeof(pjob
->filename
)-1,
2748 "%s/%sXXXXXX", lp_pathname(talloc_tos(), snum
),
2749 PRINT_SPOOL_PREFIX
);
2750 mask
= umask(S_IRWXO
| S_IRWXG
);
2751 pjob
->fd
= mkstemp(pjob
->filename
);
2754 if (pjob
->fd
== -1) {
2755 werr
= map_werror_from_unix(errno
);
2756 if (W_ERROR_EQUAL(werr
, WERR_ACCESS_DENIED
)) {
2757 /* Common setup error, force a report. */
2758 DEBUG(0, ("print_job_spool_file: "
2759 "insufficient permissions to open spool "
2760 "file %s.\n", pjob
->filename
));
2762 /* Normal case, report at level 3 and above. */
2763 DEBUG(3, ("print_job_spool_file: "
2764 "can't open spool file %s\n",
2773 /***************************************************************************
2774 Start spooling a job - return the jobid.
2775 ***************************************************************************/
2777 WERROR
print_job_start(const struct auth_session_info
*server_info
,
2778 struct messaging_context
*msg_ctx
,
2779 const char *clientmachine
,
2780 int snum
, const char *docname
, const char *filename
,
2781 struct spoolss_DeviceMode
*devmode
, uint32_t *_jobid
)
2785 struct printjob pjob
;
2786 const char *sharename
= lp_const_servicename(snum
);
2787 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
2792 return WERR_INTERNAL_DB_CORRUPTION
;
2795 path
= lp_pathname(talloc_tos(), snum
);
2797 werr
= print_job_checks(server_info
, msg_ctx
, snum
, &njobs
);
2798 if (!W_ERROR_IS_OK(werr
)) {
2799 release_print_db(pdb
);
2803 DEBUG(10, ("print_job_start: "
2804 "Queue %s number of jobs (%d), max printjobs = %d\n",
2805 sharename
, njobs
, lp_maxprintjobs(snum
)));
2807 werr
= allocate_print_jobid(pdb
, snum
, sharename
, &jobid
);
2808 if (!W_ERROR_IS_OK(werr
)) {
2812 /* create the database entry */
2816 pjob
.pid
= getpid();
2820 pjob
.starttime
= time(NULL
);
2821 pjob
.status
= LPQ_SPOOLING
;
2823 pjob
.spooled
= False
;
2825 pjob
.devmode
= devmode
;
2827 fstrcpy(pjob
.jobname
, docname
);
2829 fstrcpy(pjob
.clientmachine
, clientmachine
);
2831 fstrcpy(pjob
.user
, lp_printjob_username(snum
));
2832 standard_sub_advanced(sharename
, server_info
->unix_info
->sanitized_username
,
2833 path
, server_info
->unix_token
->gid
,
2834 server_info
->unix_info
->sanitized_username
,
2835 server_info
->info
->domain_name
,
2836 pjob
.user
, sizeof(pjob
.user
));
2838 fstrcpy(pjob
.queuename
, lp_const_servicename(snum
));
2840 /* we have a job entry - now create the spool file */
2841 werr
= print_job_spool_file(snum
, jobid
, filename
, &pjob
);
2842 if (!W_ERROR_IS_OK(werr
)) {
2846 pjob_store(server_event_context(), msg_ctx
, sharename
, jobid
, &pjob
);
2848 /* Update the 'jobs added' entry used by print_queue_status. */
2849 add_to_jobs_added(pdb
, jobid
);
2851 /* Ensure we keep a rough count of the number of total jobs... */
2852 tdb_change_int32_atomic(pdb
->tdb
, "INFO/total_jobs", &njobs
, 1);
2854 release_print_db(pdb
);
2861 pjob_delete(server_event_context(), msg_ctx
, sharename
, jobid
);
2864 release_print_db(pdb
);
2866 DEBUG(3, ("print_job_start: returning fail. "
2867 "Error = %s\n", win_errstr(werr
)));
2871 /****************************************************************************
2872 Update the number of pages spooled to jobid
2873 ****************************************************************************/
2875 void print_job_endpage(struct messaging_context
*msg_ctx
,
2876 int snum
, uint32 jobid
)
2878 const char* sharename
= lp_const_servicename(snum
);
2879 struct printjob
*pjob
;
2880 TALLOC_CTX
*tmp_ctx
= talloc_new(msg_ctx
);
2881 if (tmp_ctx
== NULL
) {
2885 pjob
= print_job_find(tmp_ctx
, sharename
, jobid
);
2889 /* don't allow another process to get this info - it is meaningless */
2890 if (pjob
->pid
!= getpid()) {
2895 pjob_store(server_event_context(), msg_ctx
, sharename
, jobid
, pjob
);
2897 talloc_free(tmp_ctx
);
2900 /****************************************************************************
2901 Print a file - called on closing the file. This spools the job.
2902 If normal close is false then we're tearing down the jobs - treat as an
2904 ****************************************************************************/
2906 NTSTATUS
print_job_end(struct messaging_context
*msg_ctx
, int snum
,
2907 uint32 jobid
, enum file_close_type close_type
)
2909 const char* sharename
= lp_const_servicename(snum
);
2910 struct printjob
*pjob
;
2912 SMB_STRUCT_STAT sbuf
;
2913 struct printif
*current_printif
= get_printer_fns(snum
);
2914 NTSTATUS status
= NT_STATUS_UNSUCCESSFUL
;
2916 TALLOC_CTX
*tmp_ctx
= talloc_new(msg_ctx
);
2917 if (tmp_ctx
== NULL
) {
2918 return NT_STATUS_NO_MEMORY
;
2921 pjob
= print_job_find(tmp_ctx
, sharename
, jobid
);
2923 status
= NT_STATUS_PRINT_CANCELLED
;
2927 if (pjob
->spooled
|| pjob
->pid
!= getpid()) {
2928 status
= NT_STATUS_ACCESS_DENIED
;
2932 if (close_type
== NORMAL_CLOSE
|| close_type
== SHUTDOWN_CLOSE
) {
2933 if (pjob
->status
== PJOB_SMBD_SPOOLING
) {
2934 /* take over the file now, smbd is done */
2935 if (sys_stat(pjob
->filename
, &sbuf
, false) != 0) {
2936 status
= map_nt_error_from_unix(errno
);
2937 DEBUG(3, ("print_job_end: "
2938 "stat file failed for jobid %d\n",
2943 pjob
->status
= LPQ_SPOOLING
;
2947 if ((sys_fstat(pjob
->fd
, &sbuf
, false) != 0)) {
2948 status
= map_nt_error_from_unix(errno
);
2950 DEBUG(3, ("print_job_end: "
2951 "stat file failed for jobid %d\n",
2959 pjob
->size
= sbuf
.st_ex_size
;
2963 * Not a normal close, something has gone wrong. Cleanup.
2965 if (pjob
->fd
!= -1) {
2971 /* Technically, this is not quite right. If the printer has a separator
2972 * page turned on, the NT spooler prints the separator page even if the
2973 * print job is 0 bytes. 010215 JRR */
2974 if (pjob
->size
== 0 || pjob
->status
== LPQ_DELETING
) {
2975 /* don't bother spooling empty files or something being deleted. */
2976 DEBUG(5,("print_job_end: canceling spool of %s (%s)\n",
2977 pjob
->filename
, pjob
->size
? "deleted" : "zero length" ));
2978 unlink(pjob
->filename
);
2979 pjob_delete(server_event_context(), msg_ctx
, sharename
, jobid
);
2980 return NT_STATUS_OK
;
2983 /* don't strip out characters like '$' from the printername */
2984 lpq_cmd
= talloc_string_sub2(tmp_ctx
,
2985 lp_lpqcommand(talloc_tos(), snum
),
2987 lp_printername(talloc_tos(), snum
),
2988 false, false, false);
2989 if (lpq_cmd
== NULL
) {
2990 status
= NT_STATUS_PRINT_CANCELLED
;
2993 lpq_cmd
= talloc_sub_advanced(tmp_ctx
,
2994 lp_servicename(talloc_tos(), snum
),
2995 current_user_info
.unix_name
,
2997 current_user
.ut
.gid
,
2998 get_current_username(),
2999 current_user_info
.domain
,
3001 if (lpq_cmd
== NULL
) {
3002 status
= NT_STATUS_PRINT_CANCELLED
;
3006 ret
= (*(current_printif
->job_submit
))(snum
, pjob
,
3007 current_printif
->type
, lpq_cmd
);
3009 status
= NT_STATUS_PRINT_CANCELLED
;
3013 /* The print job has been successfully handed over to the back-end */
3015 pjob
->spooled
= True
;
3016 pjob
->status
= LPQ_QUEUED
;
3017 pjob_store(server_event_context(), msg_ctx
, sharename
, jobid
, pjob
);
3019 /* make sure the database is up to date */
3020 if (print_cache_expired(lp_const_servicename(snum
), True
))
3021 print_queue_update(msg_ctx
, snum
, False
);
3023 return NT_STATUS_OK
;
3027 /* The print job was not successfully started. Cleanup */
3028 /* Still need to add proper error return propagation! 010122:JRR */
3030 unlink(pjob
->filename
);
3031 pjob_delete(server_event_context(), msg_ctx
, sharename
, jobid
);
3033 talloc_free(tmp_ctx
);
3037 /****************************************************************************
3038 Get a snapshot of jobs in the system without traversing.
3039 ****************************************************************************/
3041 static bool get_stored_queue_info(struct messaging_context
*msg_ctx
,
3042 struct tdb_print_db
*pdb
, int snum
,
3043 int *pcount
, print_queue_struct
**ppqueue
)
3045 TDB_DATA data
, cgdata
, jcdata
;
3046 print_queue_struct
*queue
= NULL
;
3048 uint32 extra_count
= 0;
3049 uint32_t changed_count
= 0;
3050 int total_count
= 0;
3053 int max_reported_jobs
= lp_max_reported_jobs(snum
);
3055 const char* sharename
= lp_servicename(talloc_tos(), snum
);
3056 TALLOC_CTX
*tmp_ctx
= talloc_new(msg_ctx
);
3057 if (tmp_ctx
== NULL
) {
3061 /* make sure the database is up to date */
3062 if (print_cache_expired(lp_const_servicename(snum
), True
))
3063 print_queue_update(msg_ctx
, snum
, False
);
3069 ZERO_STRUCT(cgdata
);
3071 /* Get the stored queue data. */
3072 data
= tdb_fetch_compat(pdb
->tdb
, string_tdb_data("INFO/linear_queue_array"));
3074 if (data
.dptr
&& data
.dsize
>= sizeof(qcount
))
3075 len
+= tdb_unpack(data
.dptr
+ len
, data
.dsize
- len
, "d", &qcount
);
3077 /* Get the added jobs list. */
3078 cgdata
= tdb_fetch_compat(pdb
->tdb
, string_tdb_data("INFO/jobs_added"));
3079 if (cgdata
.dptr
!= NULL
&& (cgdata
.dsize
% 4 == 0))
3080 extra_count
= cgdata
.dsize
/4;
3082 /* Get the changed jobs list. */
3083 jcdata
= tdb_fetch_compat(pdb
->tdb
, string_tdb_data("INFO/jobs_changed"));
3084 if (jcdata
.dptr
!= NULL
&& (jcdata
.dsize
% 4 == 0))
3085 changed_count
= jcdata
.dsize
/ 4;
3087 DEBUG(5,("get_stored_queue_info: qcount = %u, extra_count = %u\n", (unsigned int)qcount
, (unsigned int)extra_count
));
3089 /* Allocate the queue size. */
3090 if (qcount
== 0 && extra_count
== 0)
3093 if ((queue
= SMB_MALLOC_ARRAY(print_queue_struct
, qcount
+ extra_count
)) == NULL
)
3096 /* Retrieve the linearised queue data. */
3098 for(i
= 0; i
< qcount
; i
++) {
3099 uint32 qjob
, qsize
, qpage_count
, qstatus
, qpriority
, qtime
;
3100 len
+= tdb_unpack(data
.dptr
+ len
, data
.dsize
- len
, "ddddddff",
3109 queue
[i
].sysjob
= qjob
;
3110 queue
[i
].size
= qsize
;
3111 queue
[i
].page_count
= qpage_count
;
3112 queue
[i
].status
= qstatus
;
3113 queue
[i
].priority
= qpriority
;
3114 queue
[i
].time
= qtime
;
3117 total_count
= qcount
;
3119 /* Add new jobids to the queue. */
3120 for (i
= 0; i
< extra_count
; i
++) {
3122 struct printjob
*pjob
;
3124 jobid
= IVAL(cgdata
.dptr
, i
*4);
3125 DEBUG(5,("get_stored_queue_info: added job = %u\n", (unsigned int)jobid
));
3126 pjob
= print_job_find(tmp_ctx
, lp_const_servicename(snum
), jobid
);
3128 DEBUG(5,("get_stored_queue_info: failed to find added job = %u\n", (unsigned int)jobid
));
3129 remove_from_jobs_added(sharename
, jobid
);
3133 queue
[total_count
].sysjob
= pjob
->sysjob
;
3134 queue
[total_count
].size
= pjob
->size
;
3135 queue
[total_count
].page_count
= pjob
->page_count
;
3136 queue
[total_count
].status
= pjob
->status
;
3137 queue
[total_count
].priority
= 1;
3138 queue
[total_count
].time
= pjob
->starttime
;
3139 fstrcpy(queue
[total_count
].fs_user
, pjob
->user
);
3140 fstrcpy(queue
[total_count
].fs_file
, pjob
->jobname
);
3145 /* Update the changed jobids. */
3146 for (i
= 0; i
< changed_count
; i
++) {
3147 uint32_t jobid
= IVAL(jcdata
.dptr
, i
* 4);
3148 struct printjob
*pjob
;
3152 pjob
= print_job_find(tmp_ctx
, sharename
, jobid
);
3154 DEBUG(5,("get_stored_queue_info: failed to find "
3155 "changed job = %u\n",
3156 (unsigned int)jobid
));
3157 remove_from_jobs_changed(sharename
, jobid
);
3161 for (j
= 0; j
< total_count
; j
++) {
3162 if (queue
[j
].sysjob
== pjob
->sysjob
) {
3169 DEBUG(5,("get_stored_queue_info: changed job: %u\n",
3170 (unsigned int)jobid
));
3172 queue
[j
].sysjob
= pjob
->sysjob
;
3173 queue
[j
].size
= pjob
->size
;
3174 queue
[j
].page_count
= pjob
->page_count
;
3175 queue
[j
].status
= pjob
->status
;
3176 queue
[j
].priority
= 1;
3177 queue
[j
].time
= pjob
->starttime
;
3178 fstrcpy(queue
[j
].fs_user
, pjob
->user
);
3179 fstrcpy(queue
[j
].fs_file
, pjob
->jobname
);
3182 DEBUG(5,("updated queue[%u], jobid: %u, sysjob: %u, "
3184 (unsigned int)j
, (unsigned int)jobid
,
3185 (unsigned int)queue
[j
].sysjob
, pjob
->jobname
));
3188 remove_from_jobs_changed(sharename
, jobid
);
3191 /* Sort the queue by submission time otherwise they are displayed
3194 TYPESAFE_QSORT(queue
, total_count
, printjob_comp
);
3196 DEBUG(5,("get_stored_queue_info: total_count = %u\n", (unsigned int)total_count
));
3198 if (max_reported_jobs
&& total_count
> max_reported_jobs
)
3199 total_count
= max_reported_jobs
;
3202 *pcount
= total_count
;
3208 SAFE_FREE(data
.dptr
);
3209 SAFE_FREE(cgdata
.dptr
);
3210 talloc_free(tmp_ctx
);
3214 /****************************************************************************
3215 Get a printer queue listing.
3216 set queue = NULL and status = NULL if you just want to update the cache
3217 ****************************************************************************/
3219 int print_queue_status(struct messaging_context
*msg_ctx
, int snum
,
3220 print_queue_struct
**ppqueue
,
3221 print_status_struct
*status
)
3225 const char *sharename
;
3226 struct tdb_print_db
*pdb
;
3229 /* make sure the database is up to date */
3231 if (print_cache_expired(lp_const_servicename(snum
), True
))
3232 print_queue_update(msg_ctx
, snum
, False
);
3234 /* return if we are done */
3235 if ( !ppqueue
|| !status
)
3239 sharename
= lp_const_servicename(snum
);
3240 pdb
= get_print_db_byname(sharename
);
3246 * Fetch the queue status. We must do this first, as there may
3247 * be no jobs in the queue.
3250 ZERO_STRUCTP(status
);
3251 slprintf(keystr
, sizeof(keystr
)-1, "STATUS/%s", sharename
);
3252 key
= string_tdb_data(keystr
);
3254 data
= tdb_fetch_compat(pdb
->tdb
, key
);
3256 if (data
.dsize
== sizeof(*status
)) {
3257 /* this memcpy is ok since the status struct was
3258 not packed before storing it in the tdb */
3259 memcpy(status
, data
.dptr
, sizeof(*status
));
3261 SAFE_FREE(data
.dptr
);
3265 * Now, fetch the print queue information. We first count the number
3266 * of entries, and then only retrieve the queue if necessary.
3269 if (!get_stored_queue_info(msg_ctx
, pdb
, snum
, &count
, ppqueue
)) {
3270 release_print_db(pdb
);
3274 release_print_db(pdb
);
3278 /****************************************************************************
3280 ****************************************************************************/
3282 WERROR
print_queue_pause(const struct auth_session_info
*server_info
,
3283 struct messaging_context
*msg_ctx
, int snum
)
3286 struct printif
*current_printif
= get_printer_fns( snum
);
3288 if (!print_access_check(server_info
, msg_ctx
, snum
,
3289 PRINTER_ACCESS_ADMINISTER
)) {
3290 return WERR_ACCESS_DENIED
;
3296 ret
= (*(current_printif
->queue_pause
))(snum
);
3301 return WERR_INVALID_PARAM
;
3304 /* force update the database */
3305 print_cache_flush(lp_const_servicename(snum
));
3307 /* Send a printer notify message */
3309 notify_printer_status(server_event_context(), msg_ctx
, snum
,
3310 PRINTER_STATUS_PAUSED
);
3315 /****************************************************************************
3317 ****************************************************************************/
3319 WERROR
print_queue_resume(const struct auth_session_info
*server_info
,
3320 struct messaging_context
*msg_ctx
, int snum
)
3323 struct printif
*current_printif
= get_printer_fns( snum
);
3325 if (!print_access_check(server_info
, msg_ctx
, snum
,
3326 PRINTER_ACCESS_ADMINISTER
)) {
3327 return WERR_ACCESS_DENIED
;
3332 ret
= (*(current_printif
->queue_resume
))(snum
);
3337 return WERR_INVALID_PARAM
;
3340 /* make sure the database is up to date */
3341 if (print_cache_expired(lp_const_servicename(snum
), True
))
3342 print_queue_update(msg_ctx
, snum
, True
);
3344 /* Send a printer notify message */
3346 notify_printer_status(server_event_context(), msg_ctx
, snum
,
3352 /****************************************************************************
3353 Purge a queue - implemented by deleting all jobs that we can delete.
3354 ****************************************************************************/
3356 WERROR
print_queue_purge(const struct auth_session_info
*server_info
,
3357 struct messaging_context
*msg_ctx
, int snum
)
3359 print_queue_struct
*queue
;
3360 print_status_struct status
;
3364 /* Force and update so the count is accurate (i.e. not a cached count) */
3365 print_queue_update(msg_ctx
, snum
, True
);
3367 can_job_admin
= print_access_check(server_info
,
3370 JOB_ACCESS_ADMINISTER
);
3371 njobs
= print_queue_status(msg_ctx
, snum
, &queue
, &status
);
3373 if ( can_job_admin
)
3376 for (i
= 0; i
< njobs
; i
++) {
3377 struct tdb_print_db
*pdb
;
3380 pdb
= get_print_db_byname(lp_const_servicename(snum
));
3382 DEBUG(1, ("failed to find printdb for %s\n",
3383 lp_const_servicename(snum
)));
3386 jobid
= sysjob_to_jobid_pdb(pdb
, queue
[i
].sysjob
);
3387 if (jobid
== (uint32_t)-1) {
3388 DEBUG(2, ("jobid for system job %d not found\n",
3390 continue; /* unix job */
3392 owner
= is_owner(server_info
, lp_const_servicename(snum
),
3395 if (owner
|| can_job_admin
) {
3396 print_job_delete1(server_event_context(), msg_ctx
,
3401 if ( can_job_admin
)
3404 /* update the cache */
3405 print_queue_update(msg_ctx
, snum
, True
);