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"
32 #include "smbd/smbd.h"
37 extern struct current_user current_user
;
38 extern userdom_struct current_user_info
;
40 /* Current printer interface */
41 static bool remove_from_jobs_added(const char* sharename
, uint32 jobid
);
44 the printing backend revolves around a tdb database that stores the
45 SMB view of the print queue
47 The key for this database is a jobid - a internally generated number that
48 uniquely identifies a print job
50 reading the print queue involves two steps:
51 - possibly running lpq and updating the internal database from that
52 - reading entries from the database
54 jobids are assigned when a job starts spooling.
57 static TDB_CONTEXT
*rap_tdb
;
58 static uint16 next_rap_jobid
;
59 struct rap_jobid_key
{
64 /***************************************************************************
65 Nightmare. LANMAN jobid's are 16 bit numbers..... We must map them to 32
66 bit RPC jobids.... JRA.
67 ***************************************************************************/
69 uint16
pjobid_to_rap(const char* sharename
, uint32 jobid
)
73 struct rap_jobid_key jinfo
;
76 DEBUG(10,("pjobid_to_rap: called.\n"));
79 /* Create the in-memory tdb. */
80 rap_tdb
= tdb_open_log(NULL
, 0, TDB_INTERNAL
, (O_RDWR
|O_CREAT
), 0644);
86 fstrcpy( jinfo
.sharename
, sharename
);
88 key
.dptr
= (uint8
*)&jinfo
;
89 key
.dsize
= sizeof(jinfo
);
91 data
= tdb_fetch(rap_tdb
, key
);
92 if (data
.dptr
&& data
.dsize
== sizeof(uint16
)) {
93 rap_jobid
= SVAL(data
.dptr
, 0);
95 DEBUG(10,("pjobid_to_rap: jobid %u maps to RAP jobid %u\n",
96 (unsigned int)jobid
, (unsigned int)rap_jobid
));
100 /* Not found - create and store mapping. */
101 rap_jobid
= ++next_rap_jobid
;
103 rap_jobid
= ++next_rap_jobid
;
104 SSVAL(buf
,0,rap_jobid
);
106 data
.dsize
= sizeof(rap_jobid
);
107 tdb_store(rap_tdb
, key
, data
, TDB_REPLACE
);
108 tdb_store(rap_tdb
, data
, key
, TDB_REPLACE
);
110 DEBUG(10,("pjobid_to_rap: created jobid %u maps to RAP jobid %u\n",
111 (unsigned int)jobid
, (unsigned int)rap_jobid
));
115 bool rap_to_pjobid(uint16 rap_jobid
, fstring sharename
, uint32
*pjobid
)
120 DEBUG(10,("rap_to_pjobid called.\n"));
125 SSVAL(buf
,0,rap_jobid
);
127 key
.dsize
= sizeof(rap_jobid
);
128 data
= tdb_fetch(rap_tdb
, key
);
129 if ( data
.dptr
&& data
.dsize
== sizeof(struct rap_jobid_key
) )
131 struct rap_jobid_key
*jinfo
= (struct rap_jobid_key
*)data
.dptr
;
132 if (sharename
!= NULL
) {
133 fstrcpy( sharename
, jinfo
->sharename
);
135 *pjobid
= jinfo
->jobid
;
136 DEBUG(10,("rap_to_pjobid: jobid %u maps to RAP jobid %u\n",
137 (unsigned int)*pjobid
, (unsigned int)rap_jobid
));
138 SAFE_FREE(data
.dptr
);
142 DEBUG(10,("rap_to_pjobid: Failed to lookup RAP jobid %u\n",
143 (unsigned int)rap_jobid
));
144 SAFE_FREE(data
.dptr
);
148 void rap_jobid_delete(const char* sharename
, uint32 jobid
)
152 struct rap_jobid_key jinfo
;
155 DEBUG(10,("rap_jobid_delete: called.\n"));
160 ZERO_STRUCT( jinfo
);
161 fstrcpy( jinfo
.sharename
, sharename
);
163 key
.dptr
= (uint8
*)&jinfo
;
164 key
.dsize
= sizeof(jinfo
);
166 data
= tdb_fetch(rap_tdb
, key
);
167 if (!data
.dptr
|| (data
.dsize
!= sizeof(uint16
))) {
168 DEBUG(10,("rap_jobid_delete: cannot find jobid %u\n",
169 (unsigned int)jobid
));
170 SAFE_FREE(data
.dptr
);
174 DEBUG(10,("rap_jobid_delete: deleting jobid %u\n",
175 (unsigned int)jobid
));
177 rap_jobid
= SVAL(data
.dptr
, 0);
178 SAFE_FREE(data
.dptr
);
179 SSVAL(buf
,0,rap_jobid
);
181 data
.dsize
= sizeof(rap_jobid
);
182 tdb_delete(rap_tdb
, key
);
183 tdb_delete(rap_tdb
, data
);
186 static int get_queue_status(const char* sharename
, print_status_struct
*);
188 /****************************************************************************
189 Initialise the printing backend. Called once at startup before the fork().
190 ****************************************************************************/
192 bool print_backend_init(struct messaging_context
*msg_ctx
)
194 const char *sversion
= "INFO/version";
195 int services
= lp_numservices();
198 unlink(cache_path("printing.tdb"));
199 mkdir(cache_path("printing"),0755);
201 /* handle a Samba upgrade */
203 for (snum
= 0; snum
< services
; snum
++) {
204 struct tdb_print_db
*pdb
;
205 if (!lp_print_ok(snum
))
208 pdb
= get_print_db_byname(lp_const_servicename(snum
));
211 if (tdb_lock_bystring(pdb
->tdb
, sversion
) == -1) {
212 DEBUG(0,("print_backend_init: Failed to open printer %s database\n", lp_const_servicename(snum
) ));
213 release_print_db(pdb
);
216 if (tdb_fetch_int32(pdb
->tdb
, sversion
) != PRINT_DATABASE_VERSION
) {
217 tdb_wipe_all(pdb
->tdb
);
218 tdb_store_int32(pdb
->tdb
, sversion
, PRINT_DATABASE_VERSION
);
220 tdb_unlock_bystring(pdb
->tdb
, sversion
);
221 release_print_db(pdb
);
224 close_all_print_db(); /* Don't leave any open. */
226 /* do NT print initialization... */
227 return nt_printing_init(msg_ctx
);
230 /****************************************************************************
231 Shut down printing backend. Called once at shutdown to close the tdb.
232 ****************************************************************************/
234 void printing_end(void)
236 close_all_print_db(); /* Don't leave any open. */
239 /****************************************************************************
240 Retrieve the set of printing functions for a given service. This allows
241 us to set the printer function table based on the value of the 'printing'
244 Use the generic interface as the default and only use cups interface only
245 when asked for (and only when supported)
246 ****************************************************************************/
248 static struct printif
*get_printer_fns_from_type( enum printing_types type
)
250 struct printif
*printer_fns
= &generic_printif
;
253 if ( type
== PRINT_CUPS
) {
254 printer_fns
= &cups_printif
;
256 #endif /* HAVE_CUPS */
259 if ( type
== PRINT_IPRINT
) {
260 printer_fns
= &iprint_printif
;
262 #endif /* HAVE_IPRINT */
264 printer_fns
->type
= type
;
269 static struct printif
*get_printer_fns( int snum
)
271 return get_printer_fns_from_type( (enum printing_types
)lp_printing(snum
) );
275 /****************************************************************************
276 Useful function to generate a tdb key.
277 ****************************************************************************/
279 static TDB_DATA
print_key(uint32 jobid
, uint32
*tmp
)
283 SIVAL(tmp
, 0, jobid
);
284 ret
.dptr
= (uint8
*)tmp
;
285 ret
.dsize
= sizeof(*tmp
);
289 /****************************************************************************
290 Pack the devicemode to store it in a tdb.
291 ****************************************************************************/
292 static int pack_devicemode(struct spoolss_DeviceMode
*devmode
, uint8
*buf
, int buflen
)
294 enum ndr_err_code ndr_err
;
299 ndr_err
= ndr_push_struct_blob(&blob
, talloc_tos(),
301 (ndr_push_flags_fn_t
)
302 ndr_push_spoolss_DeviceMode
);
303 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
304 DEBUG(10, ("pack_devicemode: "
305 "error encoding spoolss_DeviceMode\n"));
312 len
= tdb_pack(buf
, buflen
, "B", blob
.length
, blob
.data
);
315 DEBUG(8, ("Packed devicemode [%s]\n", devmode
->formname
));
322 /****************************************************************************
323 Unpack the devicemode to store it in a tdb.
324 ****************************************************************************/
325 static int unpack_devicemode(TALLOC_CTX
*mem_ctx
,
326 const uint8
*buf
, int buflen
,
327 struct spoolss_DeviceMode
**devmode
)
329 struct spoolss_DeviceMode
*dm
;
330 enum ndr_err_code ndr_err
;
338 len
= tdb_unpack(buf
, buflen
, "B", &data_len
, &data
);
343 dm
= talloc_zero(mem_ctx
, struct spoolss_DeviceMode
);
348 blob
= data_blob_const(data
, data_len
);
350 ndr_err
= ndr_pull_struct_blob(&blob
, dm
, dm
,
351 (ndr_pull_flags_fn_t
)ndr_pull_spoolss_DeviceMode
);
352 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
353 DEBUG(10, ("unpack_devicemode: "
354 "error parsing spoolss_DeviceMode\n"));
358 DEBUG(8, ("Unpacked devicemode [%s](%s)\n",
359 dm
->devicename
, dm
->formname
));
360 if (dm
->driverextra_data
.data
) {
361 DEBUG(8, ("with a private section of %d bytes\n",
362 dm
->__driverextra_length
));
372 /***********************************************************************
373 unpack a pjob from a tdb buffer
374 ***********************************************************************/
376 static int unpack_pjob(TALLOC_CTX
*mem_ctx
, uint8
*buf
, int buflen
,
377 struct printjob
*pjob
)
381 uint32 pjpid
, pjjobid
, pjsysjob
, pjfd
, pjstarttime
, pjstatus
;
382 uint32 pjsize
, pjpage_count
, pjspooled
, pjsmbjob
;
388 len
+= tdb_unpack(buf
+len
, buflen
-len
, "ddddddddddfffff",
409 used
= unpack_devicemode(mem_ctx
, buf
+len
, buflen
-len
, &pjob
->devmode
);
417 pjob
->jobid
= pjjobid
;
418 pjob
->sysjob
= pjsysjob
;
420 pjob
->starttime
= pjstarttime
;
421 pjob
->status
= pjstatus
;
423 pjob
->page_count
= pjpage_count
;
424 pjob
->spooled
= pjspooled
;
425 pjob
->smbjob
= pjsmbjob
;
431 /****************************************************************************
432 Useful function to find a print job in the database.
433 ****************************************************************************/
435 static struct printjob
*print_job_find(TALLOC_CTX
*mem_ctx
,
436 const char *sharename
,
439 struct printjob
*pjob
;
442 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
444 DEBUG(10,("print_job_find: looking up job %u for share %s\n",
445 (unsigned int)jobid
, sharename
));
451 ret
= tdb_fetch(pdb
->tdb
, print_key(jobid
, &tmp
));
452 release_print_db(pdb
);
455 DEBUG(10, ("print_job_find: failed to find jobid %u.\n",
460 pjob
= talloc_zero(mem_ctx
, struct printjob
);
465 if (unpack_pjob(mem_ctx
, ret
.dptr
, ret
.dsize
, pjob
) == -1) {
466 DEBUG(10, ("failed to unpack jobid %u.\n", jobid
));
472 DEBUG(10,("print_job_find: returning system job %d for jobid %u.\n",
473 pjob
->sysjob
, jobid
));
474 SMB_ASSERT(pjob
->jobid
== jobid
);
481 /* Convert a unix jobid to a smb jobid */
483 struct unixjob_traverse_state
{
485 uint32 sysjob_to_jobid_value
;
488 static int unixjob_traverse_fn(TDB_CONTEXT
*the_tdb
, TDB_DATA key
,
489 TDB_DATA data
, void *private_data
)
491 struct printjob
*pjob
;
492 struct unixjob_traverse_state
*state
=
493 (struct unixjob_traverse_state
*)private_data
;
495 if (!data
.dptr
|| data
.dsize
== 0)
498 pjob
= (struct printjob
*)data
.dptr
;
499 if (key
.dsize
!= sizeof(uint32
))
502 if (state
->sysjob
== pjob
->sysjob
) {
503 state
->sysjob_to_jobid_value
= pjob
->jobid
;
510 static uint32
sysjob_to_jobid_pdb(struct tdb_print_db
*pdb
, int sysjob
)
512 struct unixjob_traverse_state state
;
514 state
.sysjob
= sysjob
;
515 state
.sysjob_to_jobid_value
= (uint32
)-1;
517 tdb_traverse(pdb
->tdb
, unixjob_traverse_fn
, &state
);
519 return state
.sysjob_to_jobid_value
;
522 /****************************************************************************
523 This is a *horribly expensive call as we have to iterate through all the
524 current printer tdb's. Don't do this often ! JRA.
525 ****************************************************************************/
527 uint32
sysjob_to_jobid(int unix_jobid
)
529 int services
= lp_numservices();
531 struct unixjob_traverse_state state
;
533 state
.sysjob
= unix_jobid
;
534 state
.sysjob_to_jobid_value
= (uint32
)-1;
536 for (snum
= 0; snum
< services
; snum
++) {
537 struct tdb_print_db
*pdb
;
538 if (!lp_print_ok(snum
))
540 pdb
= get_print_db_byname(lp_const_servicename(snum
));
544 tdb_traverse(pdb
->tdb
, unixjob_traverse_fn
, &state
);
545 release_print_db(pdb
);
546 if (state
.sysjob_to_jobid_value
!= (uint32
)-1)
547 return state
.sysjob_to_jobid_value
;
552 /****************************************************************************
553 Send notifications based on what has changed after a pjob_store.
554 ****************************************************************************/
556 static const struct {
558 uint32_t spoolss_status
;
559 } lpq_to_spoolss_status_map
[] = {
560 { LPQ_QUEUED
, JOB_STATUS_QUEUED
},
561 { LPQ_PAUSED
, JOB_STATUS_PAUSED
},
562 { LPQ_SPOOLING
, JOB_STATUS_SPOOLING
},
563 { LPQ_PRINTING
, JOB_STATUS_PRINTING
},
564 { LPQ_DELETING
, JOB_STATUS_DELETING
},
565 { LPQ_OFFLINE
, JOB_STATUS_OFFLINE
},
566 { LPQ_PAPEROUT
, JOB_STATUS_PAPEROUT
},
567 { LPQ_PRINTED
, JOB_STATUS_PRINTED
},
568 { LPQ_DELETED
, JOB_STATUS_DELETED
},
569 { LPQ_BLOCKED
, JOB_STATUS_BLOCKED_DEVQ
},
570 { LPQ_USER_INTERVENTION
, JOB_STATUS_USER_INTERVENTION
},
574 /* Convert a lpq status value stored in printing.tdb into the
575 appropriate win32 API constant. */
577 static uint32
map_to_spoolss_status(uint32 lpq_status
)
581 while (lpq_to_spoolss_status_map
[i
].lpq_status
!= -1) {
582 if (lpq_to_spoolss_status_map
[i
].lpq_status
== lpq_status
)
583 return lpq_to_spoolss_status_map
[i
].spoolss_status
;
590 /***************************************************************************
591 Append a jobid to the 'jobs changed' list.
592 ***************************************************************************/
594 static bool add_to_jobs_changed(struct tdb_print_db
*pdb
, uint32_t jobid
)
597 uint32_t store_jobid
;
599 SIVAL(&store_jobid
, 0, jobid
);
600 data
.dptr
= (uint8
*) &store_jobid
;
603 DEBUG(10,("add_to_jobs_added: Added jobid %u\n", (unsigned int)jobid
));
605 return (tdb_append(pdb
->tdb
, string_tdb_data("INFO/jobs_changed"),
609 /***************************************************************************
610 Remove a jobid from the 'jobs changed' list.
611 ***************************************************************************/
613 static bool remove_from_jobs_changed(const char* sharename
, uint32_t jobid
)
615 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
619 bool gotlock
= False
;
627 key
= string_tdb_data("INFO/jobs_changed");
629 if (tdb_chainlock_with_timeout(pdb
->tdb
, key
, 5) == -1)
634 data
= tdb_fetch(pdb
->tdb
, key
);
636 if (data
.dptr
== NULL
|| data
.dsize
== 0 || (data
.dsize
% 4 != 0))
639 job_count
= data
.dsize
/ 4;
640 for (i
= 0; i
< job_count
; i
++) {
643 ch_jobid
= IVAL(data
.dptr
, i
*4);
644 if (ch_jobid
== jobid
) {
645 if (i
< job_count
-1 )
646 memmove(data
.dptr
+ (i
*4), data
.dptr
+ (i
*4) + 4, (job_count
- i
- 1)*4 );
648 if (tdb_store(pdb
->tdb
, key
, data
, TDB_REPLACE
) == -1)
658 tdb_chainunlock(pdb
->tdb
, key
);
659 SAFE_FREE(data
.dptr
);
660 release_print_db(pdb
);
662 DEBUG(10,("remove_from_jobs_changed: removed jobid %u\n", (unsigned int)jobid
));
664 DEBUG(10,("remove_from_jobs_changed: Failed to remove jobid %u\n", (unsigned int)jobid
));
668 static void pjob_store_notify(struct tevent_context
*ev
,
669 struct messaging_context
*msg_ctx
,
670 const char* sharename
, uint32 jobid
,
671 struct printjob
*old_data
,
672 struct printjob
*new_data
,
675 bool new_job
= false;
676 bool changed
= false;
678 if (old_data
== NULL
) {
682 /* ACHTUNG! Due to a bug in Samba's spoolss parsing of the
683 NOTIFY_INFO_DATA buffer, we *have* to send the job submission
684 time first or else we'll end up with potential alignment
685 errors. I don't think the systemtime should be spooled as
686 a string, but this gets us around that error.
687 --jerry (i'll feel dirty for this) */
690 notify_job_submitted(ev
, msg_ctx
,
691 sharename
, jobid
, new_data
->starttime
);
692 notify_job_username(ev
, msg_ctx
,
693 sharename
, jobid
, new_data
->user
);
694 notify_job_name(ev
, msg_ctx
,
695 sharename
, jobid
, new_data
->jobname
);
696 notify_job_status(ev
, msg_ctx
,
697 sharename
, jobid
, map_to_spoolss_status(new_data
->status
));
698 notify_job_total_bytes(ev
, msg_ctx
,
699 sharename
, jobid
, new_data
->size
);
700 notify_job_total_pages(ev
, msg_ctx
,
701 sharename
, jobid
, new_data
->page_count
);
703 if (!strequal(old_data
->jobname
, new_data
->jobname
)) {
704 notify_job_name(ev
, msg_ctx
, sharename
,
705 jobid
, new_data
->jobname
);
709 if (old_data
->status
!= new_data
->status
) {
710 notify_job_status(ev
, msg_ctx
,
712 map_to_spoolss_status(new_data
->status
));
715 if (old_data
->size
!= new_data
->size
) {
716 notify_job_total_bytes(ev
, msg_ctx
,
717 sharename
, jobid
, new_data
->size
);
720 if (old_data
->page_count
!= new_data
->page_count
) {
721 notify_job_total_pages(ev
, msg_ctx
,
723 new_data
->page_count
);
730 /****************************************************************************
731 Store a job structure back to the database.
732 ****************************************************************************/
734 static bool pjob_store(struct tevent_context
*ev
,
735 struct messaging_context
*msg_ctx
,
736 const char* sharename
, uint32 jobid
,
737 struct printjob
*pjob
)
740 TDB_DATA old_data
, new_data
;
742 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
744 int len
, newlen
, buflen
;
752 old_data
= tdb_fetch(pdb
->tdb
, print_key(jobid
, &tmp
));
754 /* Doh! Now we have to pack/unpack data since the NT_DEVICEMODE was added */
761 len
+= tdb_pack(buf
+len
, buflen
-len
, "ddddddddddfffff",
764 (uint32
)pjob
->sysjob
,
766 (uint32
)pjob
->starttime
,
767 (uint32
)pjob
->status
,
769 (uint32
)pjob
->page_count
,
770 (uint32
)pjob
->spooled
,
771 (uint32
)pjob
->smbjob
,
778 len
+= pack_devicemode(pjob
->devmode
, buf
+len
, buflen
-len
);
781 buf
= (uint8
*)SMB_REALLOC(buf
, len
);
783 DEBUG(0,("pjob_store: failed to enlarge buffer!\n"));
788 } while ( buflen
!= len
);
794 new_data
.dsize
= len
;
795 ret
= (tdb_store(pdb
->tdb
, print_key(jobid
, &tmp
), new_data
,
798 /* Send notify updates for what has changed */
801 bool changed
= false;
802 struct printjob old_pjob
;
804 if (old_data
.dsize
) {
805 TALLOC_CTX
*tmp_ctx
= talloc_new(ev
);
809 len
= unpack_pjob(tmp_ctx
, old_data
.dptr
,
810 old_data
.dsize
, &old_pjob
);
812 pjob_store_notify(ev
,
814 sharename
, jobid
, &old_pjob
,
818 add_to_jobs_changed(pdb
, jobid
);
821 talloc_free(tmp_ctx
);
825 pjob_store_notify(ev
, msg_ctx
,
826 sharename
, jobid
, NULL
, pjob
,
832 release_print_db(pdb
);
833 SAFE_FREE( old_data
.dptr
);
839 /****************************************************************************
840 Remove a job structure from the database.
841 ****************************************************************************/
843 static void pjob_delete(struct tevent_context
*ev
,
844 struct messaging_context
*msg_ctx
,
845 const char* sharename
, uint32 jobid
)
848 struct printjob
*pjob
;
849 uint32 job_status
= 0;
850 struct tdb_print_db
*pdb
;
851 TALLOC_CTX
*tmp_ctx
= talloc_new(ev
);
852 if (tmp_ctx
== NULL
) {
856 pdb
= get_print_db_byname(sharename
);
861 pjob
= print_job_find(tmp_ctx
, sharename
, jobid
);
863 DEBUG(5, ("we were asked to delete nonexistent job %u\n",
868 /* We must cycle through JOB_STATUS_DELETING and
869 JOB_STATUS_DELETED for the port monitor to delete the job
872 job_status
= JOB_STATUS_DELETING
|JOB_STATUS_DELETED
;
873 notify_job_status(ev
, msg_ctx
, sharename
, jobid
, job_status
);
875 /* Remove from printing.tdb */
877 tdb_delete(pdb
->tdb
, print_key(jobid
, &tmp
));
878 remove_from_jobs_added(sharename
, jobid
);
879 rap_jobid_delete(sharename
, jobid
);
881 release_print_db(pdb
);
883 talloc_free(tmp_ctx
);
886 /****************************************************************************
887 List a unix job in the print database.
888 ****************************************************************************/
890 static void print_unix_job(struct tevent_context
*ev
,
891 struct messaging_context
*msg_ctx
,
892 const char *sharename
, print_queue_struct
*q
,
895 struct printjob pj
, *old_pj
;
896 TALLOC_CTX
*tmp_ctx
= talloc_new(ev
);
897 if (tmp_ctx
== NULL
) {
901 if (jobid
== (uint32
)-1) {
902 jobid
= q
->sysjob
+ UNIX_JOB_START
;
905 /* Preserve the timestamp on an existing unix print job */
907 old_pj
= print_job_find(tmp_ctx
, sharename
, jobid
);
913 pj
.sysjob
= q
->sysjob
;
915 pj
.starttime
= old_pj
? old_pj
->starttime
: q
->time
;
916 pj
.status
= q
->status
;
919 fstrcpy(pj
.filename
, old_pj
? old_pj
->filename
: "");
920 if (jobid
< UNIX_JOB_START
) {
922 fstrcpy(pj
.jobname
, old_pj
? old_pj
->jobname
: "Remote Downlevel Document");
925 fstrcpy(pj
.jobname
, old_pj
? old_pj
->jobname
: q
->fs_file
);
927 fstrcpy(pj
.user
, old_pj
? old_pj
->user
: q
->fs_user
);
928 fstrcpy(pj
.queuename
, old_pj
? old_pj
->queuename
: sharename
);
930 pjob_store(ev
, msg_ctx
, sharename
, jobid
, &pj
);
931 talloc_free(tmp_ctx
);
935 struct traverse_struct
{
936 print_queue_struct
*queue
;
937 int qcount
, snum
, maxcount
, total_jobs
;
938 const char *sharename
;
940 const char *lprm_command
;
941 struct printif
*print_if
;
942 struct tevent_context
*ev
;
943 struct messaging_context
*msg_ctx
;
947 /****************************************************************************
948 Utility fn to delete any jobs that are no longer active.
949 ****************************************************************************/
951 static int traverse_fn_delete(TDB_CONTEXT
*t
, TDB_DATA key
, TDB_DATA data
, void *state
)
953 struct traverse_struct
*ts
= (struct traverse_struct
*)state
;
954 struct printjob pjob
;
958 if ( key
.dsize
!= sizeof(jobid
) )
961 if (unpack_pjob(ts
->mem_ctx
, data
.dptr
, data
.dsize
, &pjob
) == -1)
963 talloc_free(pjob
.devmode
);
967 /* remove a unix job if it isn't in the system queue any more */
968 for (i
=0;i
<ts
->qcount
;i
++) {
969 if (ts
->queue
[i
].sysjob
== pjob
.sysjob
) {
973 if (i
== ts
->qcount
) {
974 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !smbjob\n",
975 (unsigned int)jobid
));
976 pjob_delete(ts
->ev
, ts
->msg_ctx
,
977 ts
->sharename
, jobid
);
981 /* need to continue the the bottom of the function to
982 save the correct attributes */
985 /* maybe it hasn't been spooled yet */
987 /* if a job is not spooled and the process doesn't
988 exist then kill it. This cleans up after smbd
990 if (!process_exists_by_pid(pjob
.pid
)) {
991 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !process_exists (%u)\n",
992 (unsigned int)jobid
, (unsigned int)pjob
.pid
));
993 pjob_delete(ts
->ev
, ts
->msg_ctx
,
994 ts
->sharename
, jobid
);
1000 /* this check only makes sense for jobs submitted from Windows clients */
1003 for (i
=0;i
<ts
->qcount
;i
++) {
1004 if ( pjob
.status
== LPQ_DELETED
)
1007 if (ts
->queue
[i
].sysjob
== pjob
.sysjob
) {
1009 /* try to clean up any jobs that need to be deleted */
1011 if ( pjob
.status
== LPQ_DELETING
) {
1014 result
= (*(ts
->print_if
->job_delete
))(
1015 ts
->sharename
, ts
->lprm_command
, &pjob
);
1017 if ( result
!= 0 ) {
1018 /* if we can't delete, then reset the job status */
1019 pjob
.status
= LPQ_QUEUED
;
1020 pjob_store(ts
->ev
, ts
->msg_ctx
,
1021 ts
->sharename
, jobid
, &pjob
);
1024 /* if we deleted the job, the remove the tdb record */
1027 ts
->sharename
, jobid
);
1028 pjob
.status
= LPQ_DELETED
;
1038 /* The job isn't in the system queue - we have to assume it has
1039 completed, so delete the database entry. */
1041 if (i
== ts
->qcount
) {
1043 /* A race can occur between the time a job is spooled and
1044 when it appears in the lpq output. This happens when
1045 the job is added to printing.tdb when another smbd
1046 running print_queue_update() has completed a lpq and
1047 is currently traversing the printing tdb and deleting jobs.
1048 Don't delete the job if it was submitted after the lpq_time. */
1050 if (pjob
.starttime
< ts
->lpq_time
) {
1051 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to pjob.starttime (%u) < ts->lpq_time (%u)\n",
1052 (unsigned int)jobid
,
1053 (unsigned int)pjob
.starttime
,
1054 (unsigned int)ts
->lpq_time
));
1055 pjob_delete(ts
->ev
, ts
->msg_ctx
,
1056 ts
->sharename
, jobid
);
1062 /* Save the pjob attributes we will store. */
1063 ts
->queue
[i
].sysjob
= pjob
.sysjob
;
1064 ts
->queue
[i
].size
= pjob
.size
;
1065 ts
->queue
[i
].page_count
= pjob
.page_count
;
1066 ts
->queue
[i
].status
= pjob
.status
;
1067 ts
->queue
[i
].priority
= 1;
1068 ts
->queue
[i
].time
= pjob
.starttime
;
1069 fstrcpy(ts
->queue
[i
].fs_user
, pjob
.user
);
1070 fstrcpy(ts
->queue
[i
].fs_file
, pjob
.jobname
);
1077 /****************************************************************************
1078 Check if the print queue has been updated recently enough.
1079 ****************************************************************************/
1081 static void print_cache_flush(const char *sharename
)
1084 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1088 slprintf(key
, sizeof(key
)-1, "CACHE/%s", sharename
);
1089 tdb_store_int32(pdb
->tdb
, key
, -1);
1090 release_print_db(pdb
);
1093 /****************************************************************************
1094 Check if someone already thinks they are doing the update.
1095 ****************************************************************************/
1097 static pid_t
get_updating_pid(const char *sharename
)
1102 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1106 slprintf(keystr
, sizeof(keystr
)-1, "UPDATING/%s", sharename
);
1107 key
= string_tdb_data(keystr
);
1109 data
= tdb_fetch(pdb
->tdb
, key
);
1110 release_print_db(pdb
);
1111 if (!data
.dptr
|| data
.dsize
!= sizeof(pid_t
)) {
1112 SAFE_FREE(data
.dptr
);
1116 updating_pid
= IVAL(data
.dptr
, 0);
1117 SAFE_FREE(data
.dptr
);
1119 if (process_exists_by_pid(updating_pid
))
1120 return updating_pid
;
1125 /****************************************************************************
1126 Set the fact that we're doing the update, or have finished doing the update
1128 ****************************************************************************/
1130 static void set_updating_pid(const fstring sharename
, bool updating
)
1135 pid_t updating_pid
= sys_getpid();
1138 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1143 slprintf(keystr
, sizeof(keystr
)-1, "UPDATING/%s", sharename
);
1144 key
= string_tdb_data(keystr
);
1146 DEBUG(5, ("set_updating_pid: %s updating lpq cache for print share %s\n",
1147 updating
? "" : "not ",
1151 tdb_delete(pdb
->tdb
, key
);
1152 release_print_db(pdb
);
1156 SIVAL( buffer
, 0, updating_pid
);
1158 data
.dsize
= 4; /* we always assume this is a 4 byte value */
1160 tdb_store(pdb
->tdb
, key
, data
, TDB_REPLACE
);
1161 release_print_db(pdb
);
1164 /****************************************************************************
1165 Sort print jobs by submittal time.
1166 ****************************************************************************/
1168 static int printjob_comp(print_queue_struct
*j1
, print_queue_struct
*j2
)
1179 /* Sort on job start time */
1181 if (j1
->time
== j2
->time
)
1183 return (j1
->time
> j2
->time
) ? 1 : -1;
1186 /****************************************************************************
1187 Store the sorted queue representation for later portmon retrieval.
1189 ****************************************************************************/
1191 static void store_queue_struct(struct tdb_print_db
*pdb
, struct traverse_struct
*pts
)
1194 int max_reported_jobs
= lp_max_reported_jobs(pts
->snum
);
1195 print_queue_struct
*queue
= pts
->queue
;
1198 unsigned int qcount
;
1200 if (max_reported_jobs
&& (max_reported_jobs
< pts
->qcount
))
1201 pts
->qcount
= max_reported_jobs
;
1204 /* Work out the size. */
1206 data
.dsize
+= tdb_pack(NULL
, 0, "d", qcount
);
1208 for (i
= 0; i
< pts
->qcount
; i
++) {
1209 if ( queue
[i
].status
== LPQ_DELETED
)
1213 data
.dsize
+= tdb_pack(NULL
, 0, "ddddddff",
1214 (uint32
)queue
[i
].sysjob
,
1215 (uint32
)queue
[i
].size
,
1216 (uint32
)queue
[i
].page_count
,
1217 (uint32
)queue
[i
].status
,
1218 (uint32
)queue
[i
].priority
,
1219 (uint32
)queue
[i
].time
,
1224 if ((data
.dptr
= (uint8
*)SMB_MALLOC(data
.dsize
)) == NULL
)
1228 len
+= tdb_pack(data
.dptr
+ len
, data
.dsize
- len
, "d", qcount
);
1229 for (i
= 0; i
< pts
->qcount
; i
++) {
1230 if ( queue
[i
].status
== LPQ_DELETED
)
1233 len
+= tdb_pack(data
.dptr
+ len
, data
.dsize
- len
, "ddddddff",
1234 (uint32
)queue
[i
].sysjob
,
1235 (uint32
)queue
[i
].size
,
1236 (uint32
)queue
[i
].page_count
,
1237 (uint32
)queue
[i
].status
,
1238 (uint32
)queue
[i
].priority
,
1239 (uint32
)queue
[i
].time
,
1244 tdb_store(pdb
->tdb
, string_tdb_data("INFO/linear_queue_array"), data
,
1246 SAFE_FREE(data
.dptr
);
1250 static TDB_DATA
get_jobs_added_data(struct tdb_print_db
*pdb
)
1256 data
= tdb_fetch(pdb
->tdb
, string_tdb_data("INFO/jobs_added"));
1257 if (data
.dptr
== NULL
|| data
.dsize
== 0 || (data
.dsize
% 4 != 0)) {
1258 SAFE_FREE(data
.dptr
);
1265 static void check_job_added(const char *sharename
, TDB_DATA data
, uint32 jobid
)
1268 unsigned int job_count
= data
.dsize
/ 4;
1270 for (i
= 0; i
< job_count
; i
++) {
1273 ch_jobid
= IVAL(data
.dptr
, i
*4);
1274 if (ch_jobid
== jobid
)
1275 remove_from_jobs_added(sharename
, jobid
);
1279 /****************************************************************************
1280 Check if the print queue has been updated recently enough.
1281 ****************************************************************************/
1283 static bool print_cache_expired(const char *sharename
, bool check_pending
)
1286 time_t last_qscan_time
, time_now
= time(NULL
);
1287 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1288 bool result
= False
;
1293 snprintf(key
, sizeof(key
), "CACHE/%s", sharename
);
1294 last_qscan_time
= (time_t)tdb_fetch_int32(pdb
->tdb
, key
);
1297 * Invalidate the queue for 3 reasons.
1298 * (1). last queue scan time == -1.
1299 * (2). Current time - last queue scan time > allowed cache time.
1300 * (3). last queue scan time > current time + MAX_CACHE_VALID_TIME (1 hour by default).
1301 * This last test picks up machines for which the clock has been moved
1302 * forward, an lpq scan done and then the clock moved back. Otherwise
1303 * that last lpq scan would stay around for a loooong loooong time... :-). JRA.
1306 if (last_qscan_time
== ((time_t)-1)
1307 || (time_now
- last_qscan_time
) >= lp_lpqcachetime()
1308 || last_qscan_time
> (time_now
+ MAX_CACHE_VALID_TIME
))
1311 time_t msg_pending_time
;
1313 DEBUG(4, ("print_cache_expired: cache expired for queue %s "
1314 "(last_qscan_time = %d, time now = %d, qcachetime = %d)\n",
1315 sharename
, (int)last_qscan_time
, (int)time_now
,
1316 (int)lp_lpqcachetime() ));
1318 /* check if another smbd has already sent a message to update the
1319 queue. Give the pending message one minute to clear and
1320 then send another message anyways. Make sure to check for
1321 clocks that have been run forward and then back again. */
1323 snprintf(key
, sizeof(key
), "MSG_PENDING/%s", sharename
);
1326 && tdb_fetch_uint32( pdb
->tdb
, key
, &u
)
1327 && (msg_pending_time
=u
) > 0
1328 && msg_pending_time
<= time_now
1329 && (time_now
- msg_pending_time
) < 60 )
1331 DEBUG(4,("print_cache_expired: message already pending for %s. Accepting cache\n",
1340 release_print_db(pdb
);
1344 /****************************************************************************
1345 main work for updating the lpq cache for a printer queue
1346 ****************************************************************************/
1348 static void print_queue_update_internal(struct tevent_context
*ev
,
1349 struct messaging_context
*msg_ctx
,
1350 const char *sharename
,
1351 struct printif
*current_printif
,
1352 char *lpq_command
, char *lprm_command
)
1355 print_queue_struct
*queue
= NULL
;
1356 print_status_struct status
;
1357 print_status_struct old_status
;
1358 struct printjob
*pjob
;
1359 struct traverse_struct tstruct
;
1362 fstring keystr
, cachestr
;
1363 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1364 TALLOC_CTX
*tmp_ctx
= talloc_new(ev
);
1366 if ((pdb
== NULL
) || (tmp_ctx
== NULL
)) {
1370 DEBUG(5,("print_queue_update_internal: printer = %s, type = %d, lpq command = [%s]\n",
1371 sharename
, current_printif
->type
, lpq_command
));
1374 * Update the cache time FIRST ! Stops others even
1375 * attempting to get the lock and doing this
1376 * if the lpq takes a long time.
1379 slprintf(cachestr
, sizeof(cachestr
)-1, "CACHE/%s", sharename
);
1380 tdb_store_int32(pdb
->tdb
, cachestr
, (int)time(NULL
));
1382 /* get the current queue using the appropriate interface */
1383 ZERO_STRUCT(status
);
1385 qcount
= (*(current_printif
->queue_get
))(sharename
,
1386 current_printif
->type
,
1387 lpq_command
, &queue
, &status
);
1389 DEBUG(3, ("print_queue_update_internal: %d job%s in queue for %s\n",
1390 qcount
, (qcount
!= 1) ? "s" : "", sharename
));
1392 /* Sort the queue by submission time otherwise they are displayed
1395 TYPESAFE_QSORT(queue
, qcount
, printjob_comp
);
1398 any job in the internal database that is marked as spooled
1399 and doesn't exist in the system queue is considered finished
1400 and removed from the database
1402 any job in the system database but not in the internal database
1403 is added as a unix job
1405 fill in any system job numbers as we go
1407 jcdata
= get_jobs_added_data(pdb
);
1409 for (i
=0; i
<qcount
; i
++) {
1410 uint32 jobid
= sysjob_to_jobid_pdb(pdb
, queue
[i
].sysjob
);
1411 if (jobid
== (uint32
)-1) {
1412 /* assume its a unix print job */
1413 print_unix_job(ev
, msg_ctx
,
1414 sharename
, &queue
[i
], jobid
);
1418 /* we have an active SMB print job - update its status */
1419 pjob
= print_job_find(tmp_ctx
, sharename
, jobid
);
1421 /* err, somethings wrong. Probably smbd was restarted
1422 with jobs in the queue. All we can do is treat them
1423 like unix jobs. Pity. */
1424 DEBUG(1, ("queued print job %d not found in jobs list, "
1425 "assuming unix job\n", jobid
));
1426 print_unix_job(ev
, msg_ctx
,
1427 sharename
, &queue
[i
], jobid
);
1431 /* don't reset the status on jobs to be deleted */
1433 if ( pjob
->status
!= LPQ_DELETING
)
1434 pjob
->status
= queue
[i
].status
;
1436 pjob_store(ev
, msg_ctx
, sharename
, jobid
, pjob
);
1438 check_job_added(sharename
, jcdata
, jobid
);
1441 SAFE_FREE(jcdata
.dptr
);
1443 /* now delete any queued entries that don't appear in the
1445 tstruct
.queue
= queue
;
1446 tstruct
.qcount
= qcount
;
1448 tstruct
.total_jobs
= 0;
1449 tstruct
.lpq_time
= time(NULL
);
1450 tstruct
.sharename
= sharename
;
1451 tstruct
.lprm_command
= lprm_command
;
1452 tstruct
.print_if
= current_printif
;
1454 tstruct
.msg_ctx
= msg_ctx
;
1455 tstruct
.mem_ctx
= tmp_ctx
;
1457 tdb_traverse(pdb
->tdb
, traverse_fn_delete
, (void *)&tstruct
);
1459 /* Store the linearised queue, max jobs only. */
1460 store_queue_struct(pdb
, &tstruct
);
1462 SAFE_FREE(tstruct
.queue
);
1463 talloc_free(tmp_ctx
);
1465 DEBUG(10,("print_queue_update_internal: printer %s INFO/total_jobs = %d\n",
1466 sharename
, tstruct
.total_jobs
));
1468 tdb_store_int32(pdb
->tdb
, "INFO/total_jobs", tstruct
.total_jobs
);
1470 get_queue_status(sharename
, &old_status
);
1471 if (old_status
.qcount
!= qcount
)
1472 DEBUG(10,("print_queue_update_internal: queue status change %d jobs -> %d jobs for printer %s\n",
1473 old_status
.qcount
, qcount
, sharename
));
1475 /* store the new queue status structure */
1476 slprintf(keystr
, sizeof(keystr
)-1, "STATUS/%s", sharename
);
1477 key
= string_tdb_data(keystr
);
1479 status
.qcount
= qcount
;
1480 data
.dptr
= (uint8
*)&status
;
1481 data
.dsize
= sizeof(status
);
1482 tdb_store(pdb
->tdb
, key
, data
, TDB_REPLACE
);
1485 * Update the cache time again. We want to do this call
1486 * as little as possible...
1489 slprintf(keystr
, sizeof(keystr
)-1, "CACHE/%s", sharename
);
1490 tdb_store_int32(pdb
->tdb
, keystr
, (int32
)time(NULL
));
1492 /* clear the msg pending record for this queue */
1494 snprintf(keystr
, sizeof(keystr
), "MSG_PENDING/%s", sharename
);
1496 if ( !tdb_store_uint32( pdb
->tdb
, keystr
, 0 ) ) {
1497 /* log a message but continue on */
1499 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1503 release_print_db( pdb
);
1508 /****************************************************************************
1509 Update the internal database from the system print queue for a queue.
1510 obtain a lock on the print queue before proceeding (needed when mutiple
1511 smbd processes maytry to update the lpq cache concurrently).
1512 ****************************************************************************/
1514 static void print_queue_update_with_lock( struct tevent_context
*ev
,
1515 struct messaging_context
*msg_ctx
,
1516 const char *sharename
,
1517 struct printif
*current_printif
,
1518 char *lpq_command
, char *lprm_command
)
1521 struct tdb_print_db
*pdb
;
1523 DEBUG(5,("print_queue_update_with_lock: printer share = %s\n", sharename
));
1524 pdb
= get_print_db_byname(sharename
);
1528 if ( !print_cache_expired(sharename
, False
) ) {
1529 DEBUG(5,("print_queue_update_with_lock: print cache for %s is still ok\n", sharename
));
1530 release_print_db(pdb
);
1535 * Check to see if someone else is doing this update.
1536 * This is essentially a mutex on the update.
1539 if (get_updating_pid(sharename
) != -1) {
1540 release_print_db(pdb
);
1544 /* Lock the queue for the database update */
1546 slprintf(keystr
, sizeof(keystr
) - 1, "LOCK/%s", sharename
);
1547 /* Only wait 10 seconds for this. */
1548 if (tdb_lock_bystring_with_timeout(pdb
->tdb
, keystr
, 10) == -1) {
1549 DEBUG(0,("print_queue_update_with_lock: Failed to lock printer %s database\n", sharename
));
1550 release_print_db(pdb
);
1555 * Ensure that no one else got in here.
1556 * If the updating pid is still -1 then we are
1560 if (get_updating_pid(sharename
) != -1) {
1562 * Someone else is doing the update, exit.
1564 tdb_unlock_bystring(pdb
->tdb
, keystr
);
1565 release_print_db(pdb
);
1570 * We're going to do the update ourselves.
1573 /* Tell others we're doing the update. */
1574 set_updating_pid(sharename
, True
);
1577 * Allow others to enter and notice we're doing
1581 tdb_unlock_bystring(pdb
->tdb
, keystr
);
1583 /* do the main work now */
1585 print_queue_update_internal(ev
, msg_ctx
,
1586 sharename
, current_printif
,
1587 lpq_command
, lprm_command
);
1589 /* Delete our pid from the db. */
1590 set_updating_pid(sharename
, False
);
1591 release_print_db(pdb
);
1594 /****************************************************************************
1595 this is the receive function of the background lpq updater
1596 ****************************************************************************/
1597 void print_queue_receive(struct messaging_context
*msg
,
1600 struct server_id server_id
,
1604 char *lpqcommand
= NULL
, *lprmcommand
= NULL
;
1608 len
= tdb_unpack( (uint8
*)data
->data
, data
->length
, "fdPP",
1615 SAFE_FREE(lpqcommand
);
1616 SAFE_FREE(lprmcommand
);
1617 DEBUG(0,("print_queue_receive: Got invalid print queue update message\n"));
1621 print_queue_update_with_lock(server_event_context(), msg
, sharename
,
1622 get_printer_fns_from_type((enum printing_types
)printing_type
),
1623 lpqcommand
, lprmcommand
);
1625 SAFE_FREE(lpqcommand
);
1626 SAFE_FREE(lprmcommand
);
1630 static void printing_pause_fd_handler(struct tevent_context
*ev
,
1631 struct tevent_fd
*fde
,
1636 * If pause_pipe[1] is closed it means the parent smbd
1637 * and children exited or aborted.
1639 exit_server_cleanly(NULL
);
1642 extern struct child_pid
*children
;
1643 extern int num_children
;
1645 static void add_child_pid(pid_t pid
)
1647 struct child_pid
*child
;
1649 child
= SMB_MALLOC_P(struct child_pid
);
1650 if (child
== NULL
) {
1651 DEBUG(0, ("Could not add child struct -- malloc failed\n"));
1655 DLIST_ADD(children
, child
);
1659 static bool printer_housekeeping_fn(const struct timeval
*now
,
1662 static time_t last_pcap_reload_time
= 0;
1663 time_t printcap_cache_time
= (time_t)lp_printcap_cache_time();
1664 time_t t
= time_mono(NULL
);
1666 DEBUG(5, ("printer housekeeping\n"));
1668 /* if periodic printcap rescan is enabled, see if it's time to reload */
1669 if ((printcap_cache_time
!= 0)
1670 && (t
>= (last_pcap_reload_time
+ printcap_cache_time
))) {
1671 DEBUG( 3,( "Printcap cache time expired.\n"));
1672 pcap_cache_reload(server_event_context(),
1673 smbd_messaging_context(),
1674 &reload_pcap_change_notify
);
1675 last_pcap_reload_time
= t
;
1681 static pid_t background_lpq_updater_pid
= -1;
1683 /****************************************************************************
1684 main thread of the background lpq updater
1685 ****************************************************************************/
1686 void start_background_queue(struct tevent_context
*ev
,
1687 struct messaging_context
*msg_ctx
)
1689 /* Use local variables for this as we don't
1690 * need to save the parent side of this, just
1691 * ensure it closes when the process exits.
1695 DEBUG(3,("start_background_queue: Starting background LPQ thread\n"));
1697 if (pipe(pause_pipe
) == -1) {
1698 DEBUG(5,("start_background_queue: cannot create pipe. %s\n", strerror(errno
) ));
1702 background_lpq_updater_pid
= sys_fork();
1704 if (background_lpq_updater_pid
== -1) {
1705 DEBUG(5,("start_background_queue: background LPQ thread failed to start. %s\n", strerror(errno
) ));
1709 /* Track the printing pid along with other smbd children */
1710 add_child_pid(background_lpq_updater_pid
);
1712 if(background_lpq_updater_pid
== 0) {
1713 struct tevent_fd
*fde
;
1718 DEBUG(5,("start_background_queue: background LPQ thread started\n"));
1720 close(pause_pipe
[0]);
1723 status
= reinit_after_fork(msg_ctx
, ev
, procid_self(), true);
1725 if (!NT_STATUS_IS_OK(status
)) {
1726 DEBUG(0,("reinit_after_fork() failed\n"));
1727 smb_panic("reinit_after_fork() failed");
1730 smbd_setup_sig_term_handler();
1731 smbd_setup_sig_hup_handler(ev
, msg_ctx
);
1733 if (!serverid_register(procid_self(),
1734 FLAG_MSG_GENERAL
|FLAG_MSG_SMBD
1735 |FLAG_MSG_PRINT_GENERAL
)) {
1739 if (!locking_init()) {
1743 messaging_register(msg_ctx
, NULL
, MSG_PRINTER_UPDATE
,
1744 print_queue_receive
);
1746 fde
= tevent_add_fd(ev
, ev
, pause_pipe
[1], TEVENT_FD_READ
,
1747 printing_pause_fd_handler
,
1750 DEBUG(0,("tevent_add_fd() failed for pause_pipe\n"));
1751 smb_panic("tevent_add_fd() failed for pause_pipe");
1754 if (!(event_add_idle(ev
, NULL
,
1755 timeval_set(SMBD_HOUSEKEEPING_INTERVAL
, 0),
1756 "printer_housekeeping",
1757 printer_housekeeping_fn
,
1759 DEBUG(0, ("Could not add printing housekeeping event\n"));
1763 DEBUG(5,("start_background_queue: background LPQ thread waiting for messages\n"));
1764 ret
= tevent_loop_wait(ev
);
1765 /* should not be reached */
1766 DEBUG(0,("background_queue: tevent_loop_wait() exited with %d - %s\n",
1767 ret
, (ret
== 0) ? "out of events" : strerror(errno
)));
1771 close(pause_pipe
[1]);
1774 /****************************************************************************
1775 update the internal database from the system print queue for a queue
1776 ****************************************************************************/
1778 static void print_queue_update(struct messaging_context
*msg_ctx
,
1779 int snum
, bool force
)
1783 char *lpqcommand
= NULL
;
1784 char *lprmcommand
= NULL
;
1785 uint8
*buffer
= NULL
;
1788 struct tdb_print_db
*pdb
;
1790 struct printif
*current_printif
;
1791 TALLOC_CTX
*ctx
= talloc_tos();
1793 fstrcpy( sharename
, lp_const_servicename(snum
));
1795 /* don't strip out characters like '$' from the printername */
1797 lpqcommand
= talloc_string_sub2(ctx
,
1798 lp_lpqcommand(snum
),
1800 lp_printername(snum
),
1801 false, false, false);
1805 lpqcommand
= talloc_sub_advanced(ctx
,
1806 lp_servicename(snum
),
1807 current_user_info
.unix_name
,
1809 current_user
.ut
.gid
,
1810 get_current_username(),
1811 current_user_info
.domain
,
1817 lprmcommand
= talloc_string_sub2(ctx
,
1818 lp_lprmcommand(snum
),
1820 lp_printername(snum
),
1821 false, false, false);
1825 lprmcommand
= talloc_sub_advanced(ctx
,
1826 lp_servicename(snum
),
1827 current_user_info
.unix_name
,
1829 current_user
.ut
.gid
,
1830 get_current_username(),
1831 current_user_info
.domain
,
1838 * Make sure that the background queue process exists.
1839 * Otherwise just do the update ourselves
1842 if ( force
|| background_lpq_updater_pid
== -1 ) {
1843 DEBUG(4,("print_queue_update: updating queue [%s] myself\n", sharename
));
1844 current_printif
= get_printer_fns( snum
);
1845 print_queue_update_with_lock(server_event_context(), msg_ctx
,
1846 sharename
, current_printif
,
1847 lpqcommand
, lprmcommand
);
1852 type
= lp_printing(snum
);
1854 /* get the length */
1856 len
= tdb_pack( NULL
, 0, "fdPP",
1862 buffer
= SMB_XMALLOC_ARRAY( uint8
, len
);
1864 /* now pack the buffer */
1865 newlen
= tdb_pack( buffer
, len
, "fdPP",
1871 SMB_ASSERT( newlen
== len
);
1873 DEBUG(10,("print_queue_update: Sending message -> printer = %s, "
1874 "type = %d, lpq command = [%s] lprm command = [%s]\n",
1875 sharename
, type
, lpqcommand
, lprmcommand
));
1877 /* here we set a msg pending record for other smbd processes
1878 to throttle the number of duplicate print_queue_update msgs
1881 pdb
= get_print_db_byname(sharename
);
1887 snprintf(key
, sizeof(key
), "MSG_PENDING/%s", sharename
);
1889 if ( !tdb_store_uint32( pdb
->tdb
, key
, time(NULL
) ) ) {
1890 /* log a message but continue on */
1892 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1896 release_print_db( pdb
);
1898 /* finally send the message */
1900 messaging_send_buf(msg_ctx
, pid_to_procid(background_lpq_updater_pid
),
1901 MSG_PRINTER_UPDATE
, (uint8
*)buffer
, len
);
1903 SAFE_FREE( buffer
);
1908 /****************************************************************************
1909 Create/Update an entry in the print tdb that will allow us to send notify
1910 updates only to interested smbd's.
1911 ****************************************************************************/
1913 bool print_notify_register_pid(int snum
)
1916 struct tdb_print_db
*pdb
= NULL
;
1917 TDB_CONTEXT
*tdb
= NULL
;
1918 const char *printername
;
1919 uint32 mypid
= (uint32
)sys_getpid();
1923 /* if (snum == -1), then the change notify request was
1924 on a print server handle and we need to register on
1929 int num_services
= lp_numservices();
1932 for ( idx
=0; idx
<num_services
; idx
++ ) {
1933 if (lp_snum_ok(idx
) && lp_print_ok(idx
) )
1934 print_notify_register_pid(idx
);
1939 else /* register for a specific printer */
1941 printername
= lp_const_servicename(snum
);
1942 pdb
= get_print_db_byname(printername
);
1948 if (tdb_lock_bystring_with_timeout(tdb
, NOTIFY_PID_LIST_KEY
, 10) == -1) {
1949 DEBUG(0,("print_notify_register_pid: Failed to lock printer %s\n",
1952 release_print_db(pdb
);
1956 data
= get_printer_notify_pid_list( tdb
, printername
, True
);
1958 /* Add ourselves and increase the refcount. */
1960 for (i
= 0; i
< data
.dsize
; i
+= 8) {
1961 if (IVAL(data
.dptr
,i
) == mypid
) {
1962 uint32 new_refcount
= IVAL(data
.dptr
, i
+4) + 1;
1963 SIVAL(data
.dptr
, i
+4, new_refcount
);
1968 if (i
== data
.dsize
) {
1969 /* We weren't in the list. Realloc. */
1970 data
.dptr
= (uint8
*)SMB_REALLOC(data
.dptr
, data
.dsize
+ 8);
1972 DEBUG(0,("print_notify_register_pid: Relloc fail for printer %s\n",
1977 SIVAL(data
.dptr
,data
.dsize
- 8,mypid
);
1978 SIVAL(data
.dptr
,data
.dsize
- 4,1); /* Refcount. */
1981 /* Store back the record. */
1982 if (tdb_store_bystring(tdb
, NOTIFY_PID_LIST_KEY
, data
, TDB_REPLACE
) == -1) {
1983 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1984 list for printer %s\n", printername
));
1992 tdb_unlock_bystring(tdb
, NOTIFY_PID_LIST_KEY
);
1994 release_print_db(pdb
);
1995 SAFE_FREE(data
.dptr
);
1999 /****************************************************************************
2000 Update an entry in the print tdb that will allow us to send notify
2001 updates only to interested smbd's.
2002 ****************************************************************************/
2004 bool print_notify_deregister_pid(int snum
)
2007 struct tdb_print_db
*pdb
= NULL
;
2008 TDB_CONTEXT
*tdb
= NULL
;
2009 const char *printername
;
2010 uint32 mypid
= (uint32
)sys_getpid();
2014 /* if ( snum == -1 ), we are deregister a print server handle
2015 which means to deregister on all print queues */
2019 int num_services
= lp_numservices();
2022 for ( idx
=0; idx
<num_services
; idx
++ ) {
2023 if ( lp_snum_ok(idx
) && lp_print_ok(idx
) )
2024 print_notify_deregister_pid(idx
);
2029 else /* deregister a specific printer */
2031 printername
= lp_const_servicename(snum
);
2032 pdb
= get_print_db_byname(printername
);
2038 if (tdb_lock_bystring_with_timeout(tdb
, NOTIFY_PID_LIST_KEY
, 10) == -1) {
2039 DEBUG(0,("print_notify_register_pid: Failed to lock \
2040 printer %s database\n", printername
));
2042 release_print_db(pdb
);
2046 data
= get_printer_notify_pid_list( tdb
, printername
, True
);
2048 /* Reduce refcount. Remove ourselves if zero. */
2050 for (i
= 0; i
< data
.dsize
; ) {
2051 if (IVAL(data
.dptr
,i
) == mypid
) {
2052 uint32 refcount
= IVAL(data
.dptr
, i
+4);
2056 if (refcount
== 0) {
2057 if (data
.dsize
- i
> 8)
2058 memmove( &data
.dptr
[i
], &data
.dptr
[i
+8], data
.dsize
- i
- 8);
2062 SIVAL(data
.dptr
, i
+4, refcount
);
2068 if (data
.dsize
== 0)
2069 SAFE_FREE(data
.dptr
);
2071 /* Store back the record. */
2072 if (tdb_store_bystring(tdb
, NOTIFY_PID_LIST_KEY
, data
, TDB_REPLACE
) == -1) {
2073 DEBUG(0,("print_notify_register_pid: Failed to update pid \
2074 list for printer %s\n", printername
));
2082 tdb_unlock_bystring(tdb
, NOTIFY_PID_LIST_KEY
);
2084 release_print_db(pdb
);
2085 SAFE_FREE(data
.dptr
);
2089 /****************************************************************************
2090 Check if a jobid is valid. It is valid if it exists in the database.
2091 ****************************************************************************/
2093 bool print_job_exists(const char* sharename
, uint32 jobid
)
2095 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
2101 ret
= tdb_exists(pdb
->tdb
, print_key(jobid
, &tmp
));
2102 release_print_db(pdb
);
2106 /****************************************************************************
2107 Return the device mode asigned to a specific print job.
2108 Only valid for the process doing the spooling and when the job
2109 has not been spooled.
2110 ****************************************************************************/
2112 struct spoolss_DeviceMode
*print_job_devmode(TALLOC_CTX
*mem_ctx
,
2113 const char *sharename
,
2116 struct printjob
*pjob
= print_job_find(mem_ctx
, sharename
, jobid
);
2121 return pjob
->devmode
;
2124 /****************************************************************************
2125 Set the name of a job. Only possible for owner.
2126 ****************************************************************************/
2128 bool print_job_set_name(struct tevent_context
*ev
,
2129 struct messaging_context
*msg_ctx
,
2130 const char *sharename
, uint32 jobid
, const char *name
)
2132 struct printjob
*pjob
;
2134 TALLOC_CTX
*tmp_ctx
= talloc_new(ev
);
2135 if (tmp_ctx
== NULL
) {
2139 pjob
= print_job_find(tmp_ctx
, sharename
, jobid
);
2140 if (!pjob
|| pjob
->pid
!= sys_getpid()) {
2145 fstrcpy(pjob
->jobname
, name
);
2146 ret
= pjob_store(ev
, msg_ctx
, sharename
, jobid
, pjob
);
2148 talloc_free(tmp_ctx
);
2152 /****************************************************************************
2153 Get the name of a job. Only possible for owner.
2154 ****************************************************************************/
2156 bool print_job_get_name(TALLOC_CTX
*mem_ctx
, const char *sharename
, uint32_t jobid
, char **name
)
2158 struct printjob
*pjob
;
2160 pjob
= print_job_find(mem_ctx
, sharename
, jobid
);
2161 if (!pjob
|| pjob
->pid
!= sys_getpid()) {
2165 *name
= pjob
->jobname
;
2170 /***************************************************************************
2171 Remove a jobid from the 'jobs added' list.
2172 ***************************************************************************/
2174 static bool remove_from_jobs_added(const char* sharename
, uint32 jobid
)
2176 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
2178 size_t job_count
, i
;
2180 bool gotlock
= False
;
2188 key
= string_tdb_data("INFO/jobs_added");
2190 if (tdb_chainlock_with_timeout(pdb
->tdb
, key
, 5) == -1)
2195 data
= tdb_fetch(pdb
->tdb
, key
);
2197 if (data
.dptr
== NULL
|| data
.dsize
== 0 || (data
.dsize
% 4 != 0))
2200 job_count
= data
.dsize
/ 4;
2201 for (i
= 0; i
< job_count
; i
++) {
2204 ch_jobid
= IVAL(data
.dptr
, i
*4);
2205 if (ch_jobid
== jobid
) {
2206 if (i
< job_count
-1 )
2207 memmove(data
.dptr
+ (i
*4), data
.dptr
+ (i
*4) + 4, (job_count
- i
- 1)*4 );
2209 if (tdb_store(pdb
->tdb
, key
, data
, TDB_REPLACE
) == -1)
2219 tdb_chainunlock(pdb
->tdb
, key
);
2220 SAFE_FREE(data
.dptr
);
2221 release_print_db(pdb
);
2223 DEBUG(10,("remove_from_jobs_added: removed jobid %u\n", (unsigned int)jobid
));
2225 DEBUG(10,("remove_from_jobs_added: Failed to remove jobid %u\n", (unsigned int)jobid
));
2229 /****************************************************************************
2230 Delete a print job - don't update queue.
2231 ****************************************************************************/
2233 static bool print_job_delete1(struct tevent_context
*ev
,
2234 struct messaging_context
*msg_ctx
,
2235 int snum
, uint32 jobid
)
2237 const char* sharename
= lp_const_servicename(snum
);
2238 struct printjob
*pjob
;
2240 struct printif
*current_printif
= get_printer_fns( snum
);
2242 TALLOC_CTX
*tmp_ctx
= talloc_new(ev
);
2243 if (tmp_ctx
== NULL
) {
2247 pjob
= print_job_find(tmp_ctx
, sharename
, jobid
);
2254 * If already deleting just return.
2257 if (pjob
->status
== LPQ_DELETING
) {
2262 /* Hrm - we need to be able to cope with deleting a job before it
2263 has reached the spooler. Just mark it as LPQ_DELETING and
2264 let the print_queue_update() code rmeove the record */
2267 if (pjob
->sysjob
== -1) {
2268 DEBUG(5, ("attempt to delete job %u not seen by lpr\n", (unsigned int)jobid
));
2271 /* Set the tdb entry to be deleting. */
2273 pjob
->status
= LPQ_DELETING
;
2274 pjob_store(ev
, msg_ctx
, sharename
, jobid
, pjob
);
2276 if (pjob
->spooled
&& pjob
->sysjob
!= -1)
2278 result
= (*(current_printif
->job_delete
))(
2279 lp_printername(snum
),
2280 lp_lprmcommand(snum
),
2283 /* Delete the tdb entry if the delete succeeded or the job hasn't
2287 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
2294 pjob_delete(ev
, msg_ctx
, sharename
, jobid
);
2295 /* Ensure we keep a rough count of the number of total jobs... */
2296 tdb_change_int32_atomic(pdb
->tdb
, "INFO/total_jobs", &njobs
, -1);
2297 release_print_db(pdb
);
2301 remove_from_jobs_added( sharename
, jobid
);
2303 ret
= (result
== 0);
2305 talloc_free(tmp_ctx
);
2309 /****************************************************************************
2310 Return true if the current user owns the print job.
2311 ****************************************************************************/
2313 static bool is_owner(const struct auth_serversupplied_info
*server_info
,
2314 const char *servicename
,
2317 struct printjob
*pjob
;
2319 TALLOC_CTX
*tmp_ctx
= talloc_new(server_info
);
2320 if (tmp_ctx
== NULL
) {
2324 pjob
= print_job_find(tmp_ctx
, servicename
, jobid
);
2325 if (!pjob
|| !server_info
) {
2330 ret
= strequal(pjob
->user
, server_info
->sanitized_username
);
2332 talloc_free(tmp_ctx
);
2336 /****************************************************************************
2338 ****************************************************************************/
2340 WERROR
print_job_delete(const struct auth_serversupplied_info
*server_info
,
2341 struct messaging_context
*msg_ctx
,
2342 int snum
, uint32_t jobid
)
2344 const char* sharename
= lp_const_servicename(snum
);
2345 struct printjob
*pjob
;
2348 TALLOC_CTX
*tmp_ctx
= talloc_new(msg_ctx
);
2349 if (tmp_ctx
== NULL
) {
2350 return WERR_NOT_ENOUGH_MEMORY
;
2353 owner
= is_owner(server_info
, lp_const_servicename(snum
), jobid
);
2355 /* Check access against security descriptor or whether the user
2359 !print_access_check(server_info
, msg_ctx
, snum
,
2360 JOB_ACCESS_ADMINISTER
)) {
2361 DEBUG(3, ("delete denied by security descriptor\n"));
2363 /* BEGIN_ADMIN_LOG */
2364 sys_adminlog( LOG_ERR
,
2365 "Permission denied-- user not allowed to delete, \
2366 pause, or resume print job. User name: %s. Printer name: %s.",
2367 uidtoname(server_info
->utok
.uid
),
2368 lp_printername(snum
) );
2371 werr
= WERR_ACCESS_DENIED
;
2376 * get the spooled filename of the print job
2377 * if this works, then the file has not been spooled
2378 * to the underlying print system. Just delete the
2379 * spool file & return.
2382 pjob
= print_job_find(tmp_ctx
, sharename
, jobid
);
2383 if (!pjob
|| pjob
->spooled
|| pjob
->pid
!= getpid()) {
2384 DEBUG(10, ("Skipping spool file removal for job %u\n", jobid
));
2386 DEBUG(10, ("Removing spool file [%s]\n", pjob
->filename
));
2387 if (unlink(pjob
->filename
) == -1) {
2388 werr
= map_werror_from_unix(errno
);
2393 if (!print_job_delete1(server_event_context(), msg_ctx
, snum
, jobid
)) {
2394 werr
= WERR_ACCESS_DENIED
;
2398 /* force update the database and say the delete failed if the
2401 print_queue_update(msg_ctx
, snum
, True
);
2403 pjob
= print_job_find(tmp_ctx
, sharename
, jobid
);
2404 if (pjob
&& (pjob
->status
!= LPQ_DELETING
)) {
2405 werr
= WERR_ACCESS_DENIED
;
2408 werr
= WERR_PRINTER_HAS_JOBS_QUEUED
;
2411 talloc_free(tmp_ctx
);
2415 /****************************************************************************
2417 ****************************************************************************/
2419 WERROR
print_job_pause(const struct auth_serversupplied_info
*server_info
,
2420 struct messaging_context
*msg_ctx
,
2421 int snum
, uint32 jobid
)
2423 const char* sharename
= lp_const_servicename(snum
);
2424 struct printjob
*pjob
;
2426 struct printif
*current_printif
= get_printer_fns( snum
);
2428 TALLOC_CTX
*tmp_ctx
= talloc_new(msg_ctx
);
2429 if (tmp_ctx
== NULL
) {
2430 return WERR_NOT_ENOUGH_MEMORY
;
2433 pjob
= print_job_find(tmp_ctx
, sharename
, jobid
);
2434 if (!pjob
|| !server_info
) {
2435 DEBUG(10, ("print_job_pause: no pjob or user for jobid %u\n",
2436 (unsigned int)jobid
));
2437 werr
= WERR_INVALID_PARAM
;
2441 if (!pjob
->spooled
|| pjob
->sysjob
== -1) {
2442 DEBUG(10, ("print_job_pause: not spooled or bad sysjob = %d for jobid %u\n",
2443 (int)pjob
->sysjob
, (unsigned int)jobid
));
2444 werr
= WERR_INVALID_PARAM
;
2448 if (!is_owner(server_info
, lp_const_servicename(snum
), jobid
) &&
2449 !print_access_check(server_info
, msg_ctx
, snum
,
2450 JOB_ACCESS_ADMINISTER
)) {
2451 DEBUG(3, ("pause denied by security descriptor\n"));
2453 /* BEGIN_ADMIN_LOG */
2454 sys_adminlog( LOG_ERR
,
2455 "Permission denied-- user not allowed to delete, \
2456 pause, or resume print job. User name: %s. Printer name: %s.",
2457 uidtoname(server_info
->utok
.uid
),
2458 lp_printername(snum
) );
2461 werr
= WERR_ACCESS_DENIED
;
2465 /* need to pause the spooled entry */
2466 ret
= (*(current_printif
->job_pause
))(snum
, pjob
);
2469 werr
= WERR_INVALID_PARAM
;
2473 /* force update the database */
2474 print_cache_flush(lp_const_servicename(snum
));
2476 /* Send a printer notify message */
2478 notify_job_status(server_event_context(), msg_ctx
, sharename
, jobid
,
2481 /* how do we tell if this succeeded? */
2484 talloc_free(tmp_ctx
);
2488 /****************************************************************************
2490 ****************************************************************************/
2492 WERROR
print_job_resume(const struct auth_serversupplied_info
*server_info
,
2493 struct messaging_context
*msg_ctx
,
2494 int snum
, uint32 jobid
)
2496 const char *sharename
= lp_const_servicename(snum
);
2497 struct printjob
*pjob
;
2499 struct printif
*current_printif
= get_printer_fns( snum
);
2501 TALLOC_CTX
*tmp_ctx
= talloc_new(msg_ctx
);
2502 if (tmp_ctx
== NULL
)
2503 return WERR_NOT_ENOUGH_MEMORY
;
2505 pjob
= print_job_find(tmp_ctx
, sharename
, jobid
);
2506 if (!pjob
|| !server_info
) {
2507 DEBUG(10, ("print_job_resume: no pjob or user for jobid %u\n",
2508 (unsigned int)jobid
));
2509 werr
= WERR_INVALID_PARAM
;
2513 if (!pjob
->spooled
|| pjob
->sysjob
== -1) {
2514 DEBUG(10, ("print_job_resume: not spooled or bad sysjob = %d for jobid %u\n",
2515 (int)pjob
->sysjob
, (unsigned int)jobid
));
2516 werr
= WERR_INVALID_PARAM
;
2520 if (!is_owner(server_info
, lp_const_servicename(snum
), jobid
) &&
2521 !print_access_check(server_info
, msg_ctx
, snum
,
2522 JOB_ACCESS_ADMINISTER
)) {
2523 DEBUG(3, ("resume denied by security descriptor\n"));
2525 /* BEGIN_ADMIN_LOG */
2526 sys_adminlog( LOG_ERR
,
2527 "Permission denied-- user not allowed to delete, \
2528 pause, or resume print job. User name: %s. Printer name: %s.",
2529 uidtoname(server_info
->utok
.uid
),
2530 lp_printername(snum
) );
2532 werr
= WERR_ACCESS_DENIED
;
2536 ret
= (*(current_printif
->job_resume
))(snum
, pjob
);
2539 werr
= WERR_INVALID_PARAM
;
2543 /* force update the database */
2544 print_cache_flush(lp_const_servicename(snum
));
2546 /* Send a printer notify message */
2548 notify_job_status(server_event_context(), msg_ctx
, sharename
, jobid
,
2553 talloc_free(tmp_ctx
);
2557 /****************************************************************************
2558 Write to a print file.
2559 ****************************************************************************/
2561 ssize_t
print_job_write(struct tevent_context
*ev
,
2562 struct messaging_context
*msg_ctx
,
2563 int snum
, uint32 jobid
, const char *buf
, size_t size
)
2565 const char* sharename
= lp_const_servicename(snum
);
2566 ssize_t return_code
;
2567 struct printjob
*pjob
;
2568 TALLOC_CTX
*tmp_ctx
= talloc_new(ev
);
2569 if (tmp_ctx
== NULL
) {
2573 pjob
= print_job_find(tmp_ctx
, sharename
, jobid
);
2579 /* don't allow another process to get this info - it is meaningless */
2580 if (pjob
->pid
!= sys_getpid()) {
2585 /* if SMBD is spooling this can't be allowed */
2586 if (pjob
->status
== PJOB_SMBD_SPOOLING
) {
2591 return_code
= write_data(pjob
->fd
, buf
, size
);
2592 if (return_code
> 0) {
2594 pjob_store(ev
, msg_ctx
, sharename
, jobid
, pjob
);
2597 talloc_free(tmp_ctx
);
2601 /****************************************************************************
2602 Get the queue status - do not update if db is out of date.
2603 ****************************************************************************/
2605 static int get_queue_status(const char* sharename
, print_status_struct
*status
)
2609 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
2613 ZERO_STRUCTP(status
);
2620 fstr_sprintf(keystr
, "STATUS/%s", sharename
);
2621 data
= tdb_fetch(pdb
->tdb
, string_tdb_data(keystr
));
2623 if (data
.dsize
== sizeof(print_status_struct
))
2624 /* this memcpy is ok since the status struct was
2625 not packed before storing it in the tdb */
2626 memcpy(status
, data
.dptr
, sizeof(print_status_struct
));
2627 SAFE_FREE(data
.dptr
);
2630 len
= tdb_fetch_int32(pdb
->tdb
, "INFO/total_jobs");
2631 release_print_db(pdb
);
2632 return (len
== -1 ? 0 : len
);
2635 /****************************************************************************
2636 Determine the number of jobs in a queue.
2637 ****************************************************************************/
2639 int print_queue_length(struct messaging_context
*msg_ctx
, int snum
,
2640 print_status_struct
*pstatus
)
2642 const char* sharename
= lp_const_servicename( snum
);
2643 print_status_struct status
;
2646 ZERO_STRUCT( status
);
2648 /* make sure the database is up to date */
2649 if (print_cache_expired(lp_const_servicename(snum
), True
))
2650 print_queue_update(msg_ctx
, snum
, False
);
2652 /* also fetch the queue status */
2653 memset(&status
, 0, sizeof(status
));
2654 len
= get_queue_status(sharename
, &status
);
2662 /***************************************************************************
2663 Allocate a jobid. Hold the lock for as short a time as possible.
2664 ***************************************************************************/
2666 static WERROR
allocate_print_jobid(struct tdb_print_db
*pdb
, int snum
,
2667 const char *sharename
, uint32
*pjobid
)
2671 enum TDB_ERROR terr
;
2674 *pjobid
= (uint32
)-1;
2676 for (i
= 0; i
< 3; i
++) {
2677 /* Lock the database - only wait 20 seconds. */
2678 ret
= tdb_lock_bystring_with_timeout(pdb
->tdb
,
2679 "INFO/nextjob", 20);
2681 DEBUG(0, ("allocate_print_jobid: "
2682 "Failed to lock printing database %s\n",
2684 terr
= tdb_error(pdb
->tdb
);
2685 return ntstatus_to_werror(map_nt_error_from_tdb(terr
));
2688 if (!tdb_fetch_uint32(pdb
->tdb
, "INFO/nextjob", &jobid
)) {
2689 terr
= tdb_error(pdb
->tdb
);
2690 if (terr
!= TDB_ERR_NOEXIST
) {
2691 DEBUG(0, ("allocate_print_jobid: "
2692 "Failed to fetch INFO/nextjob "
2693 "for print queue %s\n", sharename
));
2694 tdb_unlock_bystring(pdb
->tdb
, "INFO/nextjob");
2695 return ntstatus_to_werror(map_nt_error_from_tdb(terr
));
2697 DEBUG(10, ("allocate_print_jobid: "
2698 "No existing jobid in %s\n", sharename
));
2702 DEBUG(10, ("allocate_print_jobid: "
2703 "Read jobid %u from %s\n", jobid
, sharename
));
2705 jobid
= NEXT_JOBID(jobid
);
2707 ret
= tdb_store_int32(pdb
->tdb
, "INFO/nextjob", jobid
);
2709 terr
= tdb_error(pdb
->tdb
);
2710 DEBUG(3, ("allocate_print_jobid: "
2711 "Failed to store INFO/nextjob.\n"));
2712 tdb_unlock_bystring(pdb
->tdb
, "INFO/nextjob");
2713 return ntstatus_to_werror(map_nt_error_from_tdb(terr
));
2716 /* We've finished with the INFO/nextjob lock. */
2717 tdb_unlock_bystring(pdb
->tdb
, "INFO/nextjob");
2719 if (!print_job_exists(sharename
, jobid
)) {
2722 DEBUG(10, ("allocate_print_jobid: "
2723 "Found jobid %u in %s\n", jobid
, sharename
));
2727 DEBUG(0, ("allocate_print_jobid: "
2728 "Failed to allocate a print job for queue %s\n",
2730 /* Probably full... */
2731 return WERR_NO_SPOOL_SPACE
;
2734 /* Store a dummy placeholder. */
2740 if (tdb_store(pdb
->tdb
, print_key(jobid
, &tmp
), dum
,
2741 TDB_INSERT
) == -1) {
2742 DEBUG(3, ("allocate_print_jobid: "
2743 "jobid (%d) failed to store placeholder.\n",
2745 terr
= tdb_error(pdb
->tdb
);
2746 return ntstatus_to_werror(map_nt_error_from_tdb(terr
));
2754 /***************************************************************************
2755 Append a jobid to the 'jobs added' list.
2756 ***************************************************************************/
2758 static bool add_to_jobs_added(struct tdb_print_db
*pdb
, uint32 jobid
)
2763 SIVAL(&store_jobid
, 0, jobid
);
2764 data
.dptr
= (uint8
*)&store_jobid
;
2767 DEBUG(10,("add_to_jobs_added: Added jobid %u\n", (unsigned int)jobid
));
2769 return (tdb_append(pdb
->tdb
, string_tdb_data("INFO/jobs_added"),
2774 /***************************************************************************
2775 Do all checks needed to determine if we can start a job.
2776 ***************************************************************************/
2778 static WERROR
print_job_checks(const struct auth_serversupplied_info
*server_info
,
2779 struct messaging_context
*msg_ctx
,
2780 int snum
, int *njobs
)
2782 const char *sharename
= lp_const_servicename(snum
);
2783 uint64_t dspace
, dsize
;
2787 if (!print_access_check(server_info
, msg_ctx
, snum
,
2788 PRINTER_ACCESS_USE
)) {
2789 DEBUG(3, ("print_job_checks: "
2790 "job start denied by security descriptor\n"));
2791 return WERR_ACCESS_DENIED
;
2794 if (!print_time_access_check(server_info
, msg_ctx
, sharename
)) {
2795 DEBUG(3, ("print_job_checks: "
2796 "job start denied by time check\n"));
2797 return WERR_ACCESS_DENIED
;
2800 /* see if we have sufficient disk space */
2801 if (lp_minprintspace(snum
)) {
2802 minspace
= lp_minprintspace(snum
);
2803 ret
= sys_fsusage(lp_pathname(snum
), &dspace
, &dsize
);
2804 if (ret
== 0 && dspace
< 2*minspace
) {
2805 DEBUG(3, ("print_job_checks: "
2806 "disk space check failed.\n"));
2807 return WERR_NO_SPOOL_SPACE
;
2811 /* for autoloaded printers, check that the printcap entry still exists */
2812 if (lp_autoloaded(snum
) && !pcap_printername_ok(sharename
)) {
2813 DEBUG(3, ("print_job_checks: printer name %s check failed.\n",
2815 return WERR_ACCESS_DENIED
;
2818 /* Insure the maximum queue size is not violated */
2819 *njobs
= print_queue_length(msg_ctx
, snum
, NULL
);
2820 if (*njobs
> lp_maxprintjobs(snum
)) {
2821 DEBUG(3, ("print_job_checks: Queue %s number of jobs (%d) "
2822 "larger than max printjobs per queue (%d).\n",
2823 sharename
, *njobs
, lp_maxprintjobs(snum
)));
2824 return WERR_NO_SPOOL_SPACE
;
2830 /***************************************************************************
2832 ***************************************************************************/
2834 static WERROR
print_job_spool_file(int snum
, uint32_t jobid
,
2835 const char *output_file
,
2836 struct printjob
*pjob
)
2843 /* if this file is within the printer path, it means that smbd
2844 * is spooling it and will pass us control when it is finished.
2845 * Verify that the file name is ok, within path, and it is
2846 * already already there */
2848 path
= lp_pathname(snum
);
2850 if (strncmp(output_file
, path
, len
) == 0 &&
2851 (output_file
[len
- 1] == '/' || output_file
[len
] == '/')) {
2853 /* verify path is not too long */
2854 if (strlen(output_file
) >= sizeof(pjob
->filename
)) {
2855 return WERR_INVALID_NAME
;
2858 /* verify that the file exists */
2859 if (sys_stat(output_file
, &st
, false) != 0) {
2860 return WERR_INVALID_NAME
;
2863 fstrcpy(pjob
->filename
, output_file
);
2865 DEBUG(3, ("print_job_spool_file:"
2866 "External spooling activated"));
2868 /* we do not open the file until spooling is done */
2870 pjob
->status
= PJOB_SMBD_SPOOLING
;
2876 slprintf(pjob
->filename
, sizeof(pjob
->filename
)-1,
2877 "%s/%sXXXXXX", lp_pathname(snum
), PRINT_SPOOL_PREFIX
);
2878 pjob
->fd
= mkstemp(pjob
->filename
);
2880 if (pjob
->fd
== -1) {
2881 werr
= map_werror_from_unix(errno
);
2882 if (W_ERROR_EQUAL(werr
, WERR_ACCESS_DENIED
)) {
2883 /* Common setup error, force a report. */
2884 DEBUG(0, ("print_job_spool_file: "
2885 "insufficient permissions to open spool "
2886 "file %s.\n", pjob
->filename
));
2888 /* Normal case, report at level 3 and above. */
2889 DEBUG(3, ("print_job_spool_file: "
2890 "can't open spool file %s\n",
2899 /***************************************************************************
2900 Start spooling a job - return the jobid.
2901 ***************************************************************************/
2903 WERROR
print_job_start(const struct auth_serversupplied_info
*server_info
,
2904 struct messaging_context
*msg_ctx
,
2905 const char *clientmachine
,
2906 int snum
, const char *docname
, const char *filename
,
2907 struct spoolss_DeviceMode
*devmode
, uint32_t *_jobid
)
2911 struct printjob pjob
;
2912 const char *sharename
= lp_const_servicename(snum
);
2913 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
2918 return WERR_INTERNAL_DB_CORRUPTION
;
2921 path
= lp_pathname(snum
);
2923 werr
= print_job_checks(server_info
, msg_ctx
, snum
, &njobs
);
2924 if (!W_ERROR_IS_OK(werr
)) {
2925 release_print_db(pdb
);
2929 DEBUG(10, ("print_job_start: "
2930 "Queue %s number of jobs (%d), max printjobs = %d\n",
2931 sharename
, njobs
, lp_maxprintjobs(snum
)));
2933 werr
= allocate_print_jobid(pdb
, snum
, sharename
, &jobid
);
2934 if (!W_ERROR_IS_OK(werr
)) {
2938 /* create the database entry */
2942 pjob
.pid
= sys_getpid();
2946 pjob
.starttime
= time(NULL
);
2947 pjob
.status
= LPQ_SPOOLING
;
2949 pjob
.spooled
= False
;
2951 pjob
.devmode
= devmode
;
2953 fstrcpy(pjob
.jobname
, docname
);
2955 fstrcpy(pjob
.clientmachine
, clientmachine
);
2957 fstrcpy(pjob
.user
, lp_printjob_username(snum
));
2958 standard_sub_advanced(sharename
, server_info
->sanitized_username
,
2959 path
, server_info
->utok
.gid
,
2960 server_info
->sanitized_username
,
2961 server_info
->info3
->base
.domain
.string
,
2962 pjob
.user
, sizeof(pjob
.user
)-1);
2963 /* ensure NULL termination */
2964 pjob
.user
[sizeof(pjob
.user
)-1] = '\0';
2966 fstrcpy(pjob
.queuename
, lp_const_servicename(snum
));
2968 /* we have a job entry - now create the spool file */
2969 werr
= print_job_spool_file(snum
, jobid
, filename
, &pjob
);
2970 if (!W_ERROR_IS_OK(werr
)) {
2974 pjob_store(server_event_context(), msg_ctx
, sharename
, jobid
, &pjob
);
2976 /* Update the 'jobs added' entry used by print_queue_status. */
2977 add_to_jobs_added(pdb
, jobid
);
2979 /* Ensure we keep a rough count of the number of total jobs... */
2980 tdb_change_int32_atomic(pdb
->tdb
, "INFO/total_jobs", &njobs
, 1);
2982 release_print_db(pdb
);
2989 pjob_delete(server_event_context(), msg_ctx
, sharename
, jobid
);
2992 release_print_db(pdb
);
2994 DEBUG(3, ("print_job_start: returning fail. "
2995 "Error = %s\n", win_errstr(werr
)));
2999 /****************************************************************************
3000 Update the number of pages spooled to jobid
3001 ****************************************************************************/
3003 void print_job_endpage(struct messaging_context
*msg_ctx
,
3004 int snum
, uint32 jobid
)
3006 const char* sharename
= lp_const_servicename(snum
);
3007 struct printjob
*pjob
;
3008 TALLOC_CTX
*tmp_ctx
= talloc_new(msg_ctx
);
3009 if (tmp_ctx
== NULL
) {
3013 pjob
= print_job_find(tmp_ctx
, sharename
, jobid
);
3017 /* don't allow another process to get this info - it is meaningless */
3018 if (pjob
->pid
!= sys_getpid()) {
3023 pjob_store(server_event_context(), msg_ctx
, sharename
, jobid
, pjob
);
3025 talloc_free(tmp_ctx
);
3028 /****************************************************************************
3029 Print a file - called on closing the file. This spools the job.
3030 If normal close is false then we're tearing down the jobs - treat as an
3032 ****************************************************************************/
3034 NTSTATUS
print_job_end(struct messaging_context
*msg_ctx
, int snum
,
3035 uint32 jobid
, enum file_close_type close_type
)
3037 const char* sharename
= lp_const_servicename(snum
);
3038 struct printjob
*pjob
;
3040 SMB_STRUCT_STAT sbuf
;
3041 struct printif
*current_printif
= get_printer_fns(snum
);
3042 NTSTATUS status
= NT_STATUS_UNSUCCESSFUL
;
3044 TALLOC_CTX
*tmp_ctx
= talloc_new(msg_ctx
);
3045 if (tmp_ctx
== NULL
) {
3046 return NT_STATUS_NO_MEMORY
;
3049 pjob
= print_job_find(tmp_ctx
, sharename
, jobid
);
3051 status
= NT_STATUS_PRINT_CANCELLED
;
3055 if (pjob
->spooled
|| pjob
->pid
!= sys_getpid()) {
3056 status
= NT_STATUS_ACCESS_DENIED
;
3060 if (close_type
== NORMAL_CLOSE
|| close_type
== SHUTDOWN_CLOSE
) {
3061 if (pjob
->status
== PJOB_SMBD_SPOOLING
) {
3062 /* take over the file now, smbd is done */
3063 if (sys_stat(pjob
->filename
, &sbuf
, false) != 0) {
3064 status
= map_nt_error_from_unix(errno
);
3065 DEBUG(3, ("print_job_end: "
3066 "stat file failed for jobid %d\n",
3071 pjob
->status
= LPQ_SPOOLING
;
3075 if ((sys_fstat(pjob
->fd
, &sbuf
, false) != 0)) {
3076 status
= map_nt_error_from_unix(errno
);
3078 DEBUG(3, ("print_job_end: "
3079 "stat file failed for jobid %d\n",
3087 pjob
->size
= sbuf
.st_ex_size
;
3091 * Not a normal close, something has gone wrong. Cleanup.
3093 if (pjob
->fd
!= -1) {
3099 /* Technically, this is not quite right. If the printer has a separator
3100 * page turned on, the NT spooler prints the separator page even if the
3101 * print job is 0 bytes. 010215 JRR */
3102 if (pjob
->size
== 0 || pjob
->status
== LPQ_DELETING
) {
3103 /* don't bother spooling empty files or something being deleted. */
3104 DEBUG(5,("print_job_end: canceling spool of %s (%s)\n",
3105 pjob
->filename
, pjob
->size
? "deleted" : "zero length" ));
3106 unlink(pjob
->filename
);
3107 pjob_delete(server_event_context(), msg_ctx
, sharename
, jobid
);
3108 return NT_STATUS_OK
;
3111 /* don't strip out characters like '$' from the printername */
3112 lpq_cmd
= talloc_string_sub2(tmp_ctx
,
3113 lp_lpqcommand(snum
),
3115 lp_printername(snum
),
3116 false, false, false);
3117 if (lpq_cmd
== NULL
) {
3118 status
= NT_STATUS_PRINT_CANCELLED
;
3121 lpq_cmd
= talloc_sub_advanced(tmp_ctx
,
3122 lp_servicename(snum
),
3123 current_user_info
.unix_name
,
3125 current_user
.ut
.gid
,
3126 get_current_username(),
3127 current_user_info
.domain
,
3129 if (lpq_cmd
== NULL
) {
3130 status
= NT_STATUS_PRINT_CANCELLED
;
3134 ret
= (*(current_printif
->job_submit
))(snum
, pjob
,
3135 current_printif
->type
, lpq_cmd
);
3137 status
= NT_STATUS_PRINT_CANCELLED
;
3141 /* The print job has been successfully handed over to the back-end */
3143 pjob
->spooled
= True
;
3144 pjob
->status
= LPQ_QUEUED
;
3145 pjob_store(server_event_context(), msg_ctx
, sharename
, jobid
, pjob
);
3147 /* make sure the database is up to date */
3148 if (print_cache_expired(lp_const_servicename(snum
), True
))
3149 print_queue_update(msg_ctx
, snum
, False
);
3151 return NT_STATUS_OK
;
3155 /* The print job was not successfully started. Cleanup */
3156 /* Still need to add proper error return propagation! 010122:JRR */
3158 unlink(pjob
->filename
);
3159 pjob_delete(server_event_context(), msg_ctx
, sharename
, jobid
);
3161 talloc_free(tmp_ctx
);
3165 /****************************************************************************
3166 Get a snapshot of jobs in the system without traversing.
3167 ****************************************************************************/
3169 static bool get_stored_queue_info(struct messaging_context
*msg_ctx
,
3170 struct tdb_print_db
*pdb
, int snum
,
3171 int *pcount
, print_queue_struct
**ppqueue
)
3173 TDB_DATA data
, cgdata
, jcdata
;
3174 print_queue_struct
*queue
= NULL
;
3176 uint32 extra_count
= 0;
3177 uint32_t changed_count
= 0;
3178 int total_count
= 0;
3181 int max_reported_jobs
= lp_max_reported_jobs(snum
);
3183 const char* sharename
= lp_servicename(snum
);
3184 TALLOC_CTX
*tmp_ctx
= talloc_new(msg_ctx
);
3185 if (tmp_ctx
== NULL
) {
3189 /* make sure the database is up to date */
3190 if (print_cache_expired(lp_const_servicename(snum
), True
))
3191 print_queue_update(msg_ctx
, snum
, False
);
3197 ZERO_STRUCT(cgdata
);
3199 /* Get the stored queue data. */
3200 data
= tdb_fetch(pdb
->tdb
, string_tdb_data("INFO/linear_queue_array"));
3202 if (data
.dptr
&& data
.dsize
>= sizeof(qcount
))
3203 len
+= tdb_unpack(data
.dptr
+ len
, data
.dsize
- len
, "d", &qcount
);
3205 /* Get the added jobs list. */
3206 cgdata
= tdb_fetch(pdb
->tdb
, string_tdb_data("INFO/jobs_added"));
3207 if (cgdata
.dptr
!= NULL
&& (cgdata
.dsize
% 4 == 0))
3208 extra_count
= cgdata
.dsize
/4;
3210 /* Get the changed jobs list. */
3211 jcdata
= tdb_fetch(pdb
->tdb
, string_tdb_data("INFO/jobs_changed"));
3212 if (jcdata
.dptr
!= NULL
&& (jcdata
.dsize
% 4 == 0))
3213 changed_count
= jcdata
.dsize
/ 4;
3215 DEBUG(5,("get_stored_queue_info: qcount = %u, extra_count = %u\n", (unsigned int)qcount
, (unsigned int)extra_count
));
3217 /* Allocate the queue size. */
3218 if (qcount
== 0 && extra_count
== 0)
3221 if ((queue
= SMB_MALLOC_ARRAY(print_queue_struct
, qcount
+ extra_count
)) == NULL
)
3224 /* Retrieve the linearised queue data. */
3226 for( i
= 0; i
< qcount
; i
++) {
3227 uint32 qjob
, qsize
, qpage_count
, qstatus
, qpriority
, qtime
;
3228 len
+= tdb_unpack(data
.dptr
+ len
, data
.dsize
- len
, "ddddddff",
3237 queue
[i
].sysjob
= qjob
;
3238 queue
[i
].size
= qsize
;
3239 queue
[i
].page_count
= qpage_count
;
3240 queue
[i
].status
= qstatus
;
3241 queue
[i
].priority
= qpriority
;
3242 queue
[i
].time
= qtime
;
3245 total_count
= qcount
;
3247 /* Add new jobids to the queue. */
3248 for( i
= 0; i
< extra_count
; i
++) {
3250 struct printjob
*pjob
;
3252 jobid
= IVAL(cgdata
.dptr
, i
*4);
3253 DEBUG(5,("get_stored_queue_info: added job = %u\n", (unsigned int)jobid
));
3254 pjob
= print_job_find(tmp_ctx
, lp_const_servicename(snum
), jobid
);
3256 DEBUG(5,("get_stored_queue_info: failed to find added job = %u\n", (unsigned int)jobid
));
3257 remove_from_jobs_added(sharename
, jobid
);
3261 queue
[total_count
].sysjob
= jobid
;
3262 queue
[total_count
].size
= pjob
->size
;
3263 queue
[total_count
].page_count
= pjob
->page_count
;
3264 queue
[total_count
].status
= pjob
->status
;
3265 queue
[total_count
].priority
= 1;
3266 queue
[total_count
].time
= pjob
->starttime
;
3267 fstrcpy(queue
[total_count
].fs_user
, pjob
->user
);
3268 fstrcpy(queue
[total_count
].fs_file
, pjob
->jobname
);
3273 /* Update the changed jobids. */
3274 for (i
= 0; i
< changed_count
; i
++) {
3275 uint32_t jobid
= IVAL(jcdata
.dptr
, i
* 4);
3279 for (j
= 0; j
< total_count
; j
++) {
3280 if (queue
[j
].sysjob
== jobid
) {
3287 struct printjob
*pjob
;
3289 DEBUG(5,("get_stored_queue_info: changed job: %u\n",
3290 (unsigned int) jobid
));
3292 pjob
= print_job_find(tmp_ctx
, sharename
, jobid
);
3294 DEBUG(5,("get_stored_queue_info: failed to find "
3295 "changed job = %u\n",
3296 (unsigned int) jobid
));
3297 remove_from_jobs_changed(sharename
, jobid
);
3301 queue
[j
].sysjob
= jobid
;
3302 queue
[j
].size
= pjob
->size
;
3303 queue
[j
].page_count
= pjob
->page_count
;
3304 queue
[j
].status
= pjob
->status
;
3305 queue
[j
].priority
= 1;
3306 queue
[j
].time
= pjob
->starttime
;
3307 fstrcpy(queue
[j
].fs_user
, pjob
->user
);
3308 fstrcpy(queue
[j
].fs_file
, pjob
->jobname
);
3311 DEBUG(5,("get_stored_queue_info: updated queue[%u], jobid: %u, jobname: %s\n",
3312 (unsigned int) j
, (unsigned int) jobid
, pjob
->jobname
));
3315 remove_from_jobs_changed(sharename
, jobid
);
3318 /* Sort the queue by submission time otherwise they are displayed
3321 TYPESAFE_QSORT(queue
, total_count
, printjob_comp
);
3323 DEBUG(5,("get_stored_queue_info: total_count = %u\n", (unsigned int)total_count
));
3325 if (max_reported_jobs
&& total_count
> max_reported_jobs
)
3326 total_count
= max_reported_jobs
;
3329 *pcount
= total_count
;
3335 SAFE_FREE(data
.dptr
);
3336 SAFE_FREE(cgdata
.dptr
);
3337 talloc_free(tmp_ctx
);
3341 /****************************************************************************
3342 Get a printer queue listing.
3343 set queue = NULL and status = NULL if you just want to update the cache
3344 ****************************************************************************/
3346 int print_queue_status(struct messaging_context
*msg_ctx
, int snum
,
3347 print_queue_struct
**ppqueue
,
3348 print_status_struct
*status
)
3352 const char *sharename
;
3353 struct tdb_print_db
*pdb
;
3356 /* make sure the database is up to date */
3358 if (print_cache_expired(lp_const_servicename(snum
), True
))
3359 print_queue_update(msg_ctx
, snum
, False
);
3361 /* return if we are done */
3362 if ( !ppqueue
|| !status
)
3366 sharename
= lp_const_servicename(snum
);
3367 pdb
= get_print_db_byname(sharename
);
3373 * Fetch the queue status. We must do this first, as there may
3374 * be no jobs in the queue.
3377 ZERO_STRUCTP(status
);
3378 slprintf(keystr
, sizeof(keystr
)-1, "STATUS/%s", sharename
);
3379 key
= string_tdb_data(keystr
);
3381 data
= tdb_fetch(pdb
->tdb
, key
);
3383 if (data
.dsize
== sizeof(*status
)) {
3384 /* this memcpy is ok since the status struct was
3385 not packed before storing it in the tdb */
3386 memcpy(status
, data
.dptr
, sizeof(*status
));
3388 SAFE_FREE(data
.dptr
);
3392 * Now, fetch the print queue information. We first count the number
3393 * of entries, and then only retrieve the queue if necessary.
3396 if (!get_stored_queue_info(msg_ctx
, pdb
, snum
, &count
, ppqueue
)) {
3397 release_print_db(pdb
);
3401 release_print_db(pdb
);
3405 /****************************************************************************
3407 ****************************************************************************/
3409 WERROR
print_queue_pause(const struct auth_serversupplied_info
*server_info
,
3410 struct messaging_context
*msg_ctx
, int snum
)
3413 struct printif
*current_printif
= get_printer_fns( snum
);
3415 if (!print_access_check(server_info
, msg_ctx
, snum
,
3416 PRINTER_ACCESS_ADMINISTER
)) {
3417 return WERR_ACCESS_DENIED
;
3423 ret
= (*(current_printif
->queue_pause
))(snum
);
3428 return WERR_INVALID_PARAM
;
3431 /* force update the database */
3432 print_cache_flush(lp_const_servicename(snum
));
3434 /* Send a printer notify message */
3436 notify_printer_status(server_event_context(), msg_ctx
, snum
,
3437 PRINTER_STATUS_PAUSED
);
3442 /****************************************************************************
3444 ****************************************************************************/
3446 WERROR
print_queue_resume(const struct auth_serversupplied_info
*server_info
,
3447 struct messaging_context
*msg_ctx
, int snum
)
3450 struct printif
*current_printif
= get_printer_fns( snum
);
3452 if (!print_access_check(server_info
, msg_ctx
, snum
,
3453 PRINTER_ACCESS_ADMINISTER
)) {
3454 return WERR_ACCESS_DENIED
;
3459 ret
= (*(current_printif
->queue_resume
))(snum
);
3464 return WERR_INVALID_PARAM
;
3467 /* make sure the database is up to date */
3468 if (print_cache_expired(lp_const_servicename(snum
), True
))
3469 print_queue_update(msg_ctx
, snum
, True
);
3471 /* Send a printer notify message */
3473 notify_printer_status(server_event_context(), msg_ctx
, snum
,
3479 /****************************************************************************
3480 Purge a queue - implemented by deleting all jobs that we can delete.
3481 ****************************************************************************/
3483 WERROR
print_queue_purge(const struct auth_serversupplied_info
*server_info
,
3484 struct messaging_context
*msg_ctx
, int snum
)
3486 print_queue_struct
*queue
;
3487 print_status_struct status
;
3491 /* Force and update so the count is accurate (i.e. not a cached count) */
3492 print_queue_update(msg_ctx
, snum
, True
);
3494 can_job_admin
= print_access_check(server_info
,
3497 JOB_ACCESS_ADMINISTER
);
3498 njobs
= print_queue_status(msg_ctx
, snum
, &queue
, &status
);
3500 if ( can_job_admin
)
3503 for (i
=0;i
<njobs
;i
++) {
3504 bool owner
= is_owner(server_info
, lp_const_servicename(snum
),
3507 if (owner
|| can_job_admin
) {
3508 print_job_delete1(server_event_context(), msg_ctx
,
3509 snum
, queue
[i
].sysjob
);
3513 if ( can_job_admin
)
3516 /* update the cache */
3517 print_queue_update(msg_ctx
, snum
, True
);