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/>.
25 extern struct current_user current_user
;
26 extern userdom_struct current_user_info
;
28 /* Current printer interface */
29 static bool remove_from_jobs_changed(const char* sharename
, uint32 jobid
);
32 the printing backend revolves around a tdb database that stores the
33 SMB view of the print queue
35 The key for this database is a jobid - a internally generated number that
36 uniquely identifies a print job
38 reading the print queue involves two steps:
39 - possibly running lpq and updating the internal database from that
40 - reading entries from the database
42 jobids are assigned when a job starts spooling.
45 static TDB_CONTEXT
*rap_tdb
;
46 static uint16 next_rap_jobid
;
47 struct rap_jobid_key
{
52 /***************************************************************************
53 Nightmare. LANMAN jobid's are 16 bit numbers..... We must map them to 32
54 bit RPC jobids.... JRA.
55 ***************************************************************************/
57 uint16
pjobid_to_rap(const char* sharename
, uint32 jobid
)
61 struct rap_jobid_key jinfo
;
64 DEBUG(10,("pjobid_to_rap: called.\n"));
67 /* Create the in-memory tdb. */
68 rap_tdb
= tdb_open_log(NULL
, 0, TDB_INTERNAL
, (O_RDWR
|O_CREAT
), 0644);
74 fstrcpy( jinfo
.sharename
, sharename
);
76 key
.dptr
= (uint8
*)&jinfo
;
77 key
.dsize
= sizeof(jinfo
);
79 data
= tdb_fetch(rap_tdb
, key
);
80 if (data
.dptr
&& data
.dsize
== sizeof(uint16
)) {
81 rap_jobid
= SVAL(data
.dptr
, 0);
83 DEBUG(10,("pjobid_to_rap: jobid %u maps to RAP jobid %u\n",
84 (unsigned int)jobid
, (unsigned int)rap_jobid
));
88 /* Not found - create and store mapping. */
89 rap_jobid
= ++next_rap_jobid
;
91 rap_jobid
= ++next_rap_jobid
;
92 SSVAL(buf
,0,rap_jobid
);
94 data
.dsize
= sizeof(rap_jobid
);
95 tdb_store(rap_tdb
, key
, data
, TDB_REPLACE
);
96 tdb_store(rap_tdb
, data
, key
, TDB_REPLACE
);
98 DEBUG(10,("pjobid_to_rap: created jobid %u maps to RAP jobid %u\n",
99 (unsigned int)jobid
, (unsigned int)rap_jobid
));
103 bool rap_to_pjobid(uint16 rap_jobid
, fstring sharename
, uint32
*pjobid
)
108 DEBUG(10,("rap_to_pjobid called.\n"));
113 SSVAL(buf
,0,rap_jobid
);
115 key
.dsize
= sizeof(rap_jobid
);
116 data
= tdb_fetch(rap_tdb
, key
);
117 if ( data
.dptr
&& data
.dsize
== sizeof(struct rap_jobid_key
) )
119 struct rap_jobid_key
*jinfo
= (struct rap_jobid_key
*)data
.dptr
;
120 if (sharename
!= NULL
) {
121 fstrcpy( sharename
, jinfo
->sharename
);
123 *pjobid
= jinfo
->jobid
;
124 DEBUG(10,("rap_to_pjobid: jobid %u maps to RAP jobid %u\n",
125 (unsigned int)*pjobid
, (unsigned int)rap_jobid
));
126 SAFE_FREE(data
.dptr
);
130 DEBUG(10,("rap_to_pjobid: Failed to lookup RAP jobid %u\n",
131 (unsigned int)rap_jobid
));
132 SAFE_FREE(data
.dptr
);
136 static void rap_jobid_delete(const char* sharename
, uint32 jobid
)
140 struct rap_jobid_key jinfo
;
143 DEBUG(10,("rap_jobid_delete: called.\n"));
148 ZERO_STRUCT( jinfo
);
149 fstrcpy( jinfo
.sharename
, sharename
);
151 key
.dptr
= (uint8
*)&jinfo
;
152 key
.dsize
= sizeof(jinfo
);
154 data
= tdb_fetch(rap_tdb
, key
);
155 if (!data
.dptr
|| (data
.dsize
!= sizeof(uint16
))) {
156 DEBUG(10,("rap_jobid_delete: cannot find jobid %u\n",
157 (unsigned int)jobid
));
158 SAFE_FREE(data
.dptr
);
162 DEBUG(10,("rap_jobid_delete: deleting jobid %u\n",
163 (unsigned int)jobid
));
165 rap_jobid
= SVAL(data
.dptr
, 0);
166 SAFE_FREE(data
.dptr
);
167 SSVAL(buf
,0,rap_jobid
);
169 data
.dsize
= sizeof(rap_jobid
);
170 tdb_delete(rap_tdb
, key
);
171 tdb_delete(rap_tdb
, data
);
174 static int get_queue_status(const char* sharename
, print_status_struct
*);
176 /****************************************************************************
177 Initialise the printing backend. Called once at startup before the fork().
178 ****************************************************************************/
180 bool print_backend_init(struct messaging_context
*msg_ctx
)
182 const char *sversion
= "INFO/version";
183 int services
= lp_numservices();
186 unlink(cache_path("printing.tdb"));
187 mkdir(cache_path("printing"),0755);
189 /* handle a Samba upgrade */
191 for (snum
= 0; snum
< services
; snum
++) {
192 struct tdb_print_db
*pdb
;
193 if (!lp_print_ok(snum
))
196 pdb
= get_print_db_byname(lp_const_servicename(snum
));
199 if (tdb_lock_bystring(pdb
->tdb
, sversion
) == -1) {
200 DEBUG(0,("print_backend_init: Failed to open printer %s database\n", lp_const_servicename(snum
) ));
201 release_print_db(pdb
);
204 if (tdb_fetch_int32(pdb
->tdb
, sversion
) != PRINT_DATABASE_VERSION
) {
205 tdb_wipe_all(pdb
->tdb
);
206 tdb_store_int32(pdb
->tdb
, sversion
, PRINT_DATABASE_VERSION
);
208 tdb_unlock_bystring(pdb
->tdb
, sversion
);
209 release_print_db(pdb
);
212 close_all_print_db(); /* Don't leave any open. */
214 /* do NT print initialization... */
215 return nt_printing_init(msg_ctx
);
218 /****************************************************************************
219 Shut down printing backend. Called once at shutdown to close the tdb.
220 ****************************************************************************/
222 void printing_end(void)
224 close_all_print_db(); /* Don't leave any open. */
227 /****************************************************************************
228 Retrieve the set of printing functions for a given service. This allows
229 us to set the printer function table based on the value of the 'printing'
232 Use the generic interface as the default and only use cups interface only
233 when asked for (and only when supported)
234 ****************************************************************************/
236 static struct printif
*get_printer_fns_from_type( enum printing_types type
)
238 struct printif
*printer_fns
= &generic_printif
;
241 if ( type
== PRINT_CUPS
) {
242 printer_fns
= &cups_printif
;
244 #endif /* HAVE_CUPS */
247 if ( type
== PRINT_IPRINT
) {
248 printer_fns
= &iprint_printif
;
250 #endif /* HAVE_IPRINT */
252 printer_fns
->type
= type
;
257 static struct printif
*get_printer_fns( int snum
)
259 return get_printer_fns_from_type( (enum printing_types
)lp_printing(snum
) );
263 /****************************************************************************
264 Useful function to generate a tdb key.
265 ****************************************************************************/
267 static TDB_DATA
print_key(uint32 jobid
, uint32
*tmp
)
271 SIVAL(tmp
, 0, jobid
);
272 ret
.dptr
= (uint8
*)tmp
;
273 ret
.dsize
= sizeof(*tmp
);
277 /***********************************************************************
278 unpack a pjob from a tdb buffer
279 ***********************************************************************/
281 int unpack_pjob( uint8
*buf
, int buflen
, struct printjob
*pjob
)
285 uint32 pjpid
, pjsysjob
, pjfd
, pjstarttime
, pjstatus
;
286 uint32 pjsize
, pjpage_count
, pjspooled
, pjsmbjob
;
291 len
+= tdb_unpack(buf
+len
, buflen
-len
, "dddddddddffff",
309 if ( (used
= unpack_devicemode(&pjob
->nt_devmode
, buf
+len
, buflen
-len
)) == -1 )
315 pjob
->sysjob
= pjsysjob
;
317 pjob
->starttime
= pjstarttime
;
318 pjob
->status
= pjstatus
;
320 pjob
->page_count
= pjpage_count
;
321 pjob
->spooled
= pjspooled
;
322 pjob
->smbjob
= pjsmbjob
;
328 /****************************************************************************
329 Useful function to find a print job in the database.
330 ****************************************************************************/
332 static struct printjob
*print_job_find(const char *sharename
, uint32 jobid
)
334 static struct printjob pjob
;
337 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
339 DEBUG(10,("print_job_find: looking up job %u for share %s\n",
340 (unsigned int)jobid
, sharename
));
346 ret
= tdb_fetch(pdb
->tdb
, print_key(jobid
, &tmp
));
347 release_print_db(pdb
);
350 DEBUG(10,("print_job_find: failed to find jobid %u.\n", (unsigned int)jobid
));
354 if ( pjob
.nt_devmode
) {
355 free_nt_devicemode( &pjob
.nt_devmode
);
360 if ( unpack_pjob( ret
.dptr
, ret
.dsize
, &pjob
) == -1 ) {
361 DEBUG(10,("print_job_find: failed to unpack jobid %u.\n", (unsigned int)jobid
));
368 DEBUG(10,("print_job_find: returning system job %d for jobid %u.\n",
369 (int)pjob
.sysjob
, (unsigned int)jobid
));
374 /* Convert a unix jobid to a smb jobid */
376 struct unixjob_traverse_state
{
378 uint32 sysjob_to_jobid_value
;
381 static int unixjob_traverse_fn(TDB_CONTEXT
*the_tdb
, TDB_DATA key
,
382 TDB_DATA data
, void *private_data
)
384 struct printjob
*pjob
;
385 struct unixjob_traverse_state
*state
=
386 (struct unixjob_traverse_state
*)private_data
;
388 if (!data
.dptr
|| data
.dsize
== 0)
391 pjob
= (struct printjob
*)data
.dptr
;
392 if (key
.dsize
!= sizeof(uint32
))
395 if (state
->sysjob
== pjob
->sysjob
) {
396 uint32 jobid
= IVAL(key
.dptr
,0);
398 state
->sysjob_to_jobid_value
= jobid
;
405 /****************************************************************************
406 This is a *horribly expensive call as we have to iterate through all the
407 current printer tdb's. Don't do this often ! JRA.
408 ****************************************************************************/
410 uint32
sysjob_to_jobid(int unix_jobid
)
412 int services
= lp_numservices();
414 struct unixjob_traverse_state state
;
416 state
.sysjob
= unix_jobid
;
417 state
.sysjob_to_jobid_value
= (uint32
)-1;
419 for (snum
= 0; snum
< services
; snum
++) {
420 struct tdb_print_db
*pdb
;
421 if (!lp_print_ok(snum
))
423 pdb
= get_print_db_byname(lp_const_servicename(snum
));
427 tdb_traverse(pdb
->tdb
, unixjob_traverse_fn
, &state
);
428 release_print_db(pdb
);
429 if (state
.sysjob_to_jobid_value
!= (uint32
)-1)
430 return state
.sysjob_to_jobid_value
;
435 /****************************************************************************
436 Send notifications based on what has changed after a pjob_store.
437 ****************************************************************************/
439 static const struct {
441 uint32 spoolss_status
;
442 } lpq_to_spoolss_status_map
[] = {
443 { LPQ_QUEUED
, JOB_STATUS_QUEUED
},
444 { LPQ_PAUSED
, JOB_STATUS_PAUSED
},
445 { LPQ_SPOOLING
, JOB_STATUS_SPOOLING
},
446 { LPQ_PRINTING
, JOB_STATUS_PRINTING
},
447 { LPQ_DELETING
, JOB_STATUS_DELETING
},
448 { LPQ_OFFLINE
, JOB_STATUS_OFFLINE
},
449 { LPQ_PAPEROUT
, JOB_STATUS_PAPEROUT
},
450 { LPQ_PRINTED
, JOB_STATUS_PRINTED
},
451 { LPQ_DELETED
, JOB_STATUS_DELETED
},
452 { LPQ_BLOCKED
, JOB_STATUS_BLOCKED_DEVQ
},
453 { LPQ_USER_INTERVENTION
, JOB_STATUS_USER_INTERVENTION
},
457 /* Convert a lpq status value stored in printing.tdb into the
458 appropriate win32 API constant. */
460 static uint32
map_to_spoolss_status(uint32 lpq_status
)
464 while (lpq_to_spoolss_status_map
[i
].lpq_status
!= -1) {
465 if (lpq_to_spoolss_status_map
[i
].lpq_status
== lpq_status
)
466 return lpq_to_spoolss_status_map
[i
].spoolss_status
;
473 static void pjob_store_notify(const char* sharename
, uint32 jobid
, struct printjob
*old_data
,
474 struct printjob
*new_data
)
476 bool new_job
= False
;
481 /* Job attributes that can't be changed. We only send
482 notification for these on a new job. */
484 /* ACHTUNG! Due to a bug in Samba's spoolss parsing of the
485 NOTIFY_INFO_DATA buffer, we *have* to send the job submission
486 time first or else we'll end up with potential alignment
487 errors. I don't think the systemtime should be spooled as
488 a string, but this gets us around that error.
489 --jerry (i'll feel dirty for this) */
492 notify_job_submitted(sharename
, jobid
, new_data
->starttime
);
493 notify_job_username(sharename
, jobid
, new_data
->user
);
496 if (new_job
|| !strequal(old_data
->jobname
, new_data
->jobname
))
497 notify_job_name(sharename
, jobid
, new_data
->jobname
);
499 /* Job attributes of a new job or attributes that can be
502 if (new_job
|| !strequal(old_data
->jobname
, new_data
->jobname
))
503 notify_job_name(sharename
, jobid
, new_data
->jobname
);
505 if (new_job
|| old_data
->status
!= new_data
->status
)
506 notify_job_status(sharename
, jobid
, map_to_spoolss_status(new_data
->status
));
508 if (new_job
|| old_data
->size
!= new_data
->size
)
509 notify_job_total_bytes(sharename
, jobid
, new_data
->size
);
511 if (new_job
|| old_data
->page_count
!= new_data
->page_count
)
512 notify_job_total_pages(sharename
, jobid
, new_data
->page_count
);
515 /****************************************************************************
516 Store a job structure back to the database.
517 ****************************************************************************/
519 static bool pjob_store(const char* sharename
, uint32 jobid
, struct printjob
*pjob
)
522 TDB_DATA old_data
, new_data
;
524 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
526 int len
, newlen
, buflen
;
534 old_data
= tdb_fetch(pdb
->tdb
, print_key(jobid
, &tmp
));
536 /* Doh! Now we have to pack/unpack data since the NT_DEVICEMODE was added */
543 len
+= tdb_pack(buf
+len
, buflen
-len
, "dddddddddffff",
545 (uint32
)pjob
->sysjob
,
547 (uint32
)pjob
->starttime
,
548 (uint32
)pjob
->status
,
550 (uint32
)pjob
->page_count
,
551 (uint32
)pjob
->spooled
,
552 (uint32
)pjob
->smbjob
,
558 len
+= pack_devicemode(pjob
->nt_devmode
, buf
+len
, buflen
-len
);
561 buf
= (uint8
*)SMB_REALLOC(buf
, len
);
563 DEBUG(0,("pjob_store: failed to enlarge buffer!\n"));
568 } while ( buflen
!= len
);
574 new_data
.dsize
= len
;
575 ret
= (tdb_store(pdb
->tdb
, print_key(jobid
, &tmp
), new_data
,
578 release_print_db(pdb
);
580 /* Send notify updates for what has changed */
583 struct printjob old_pjob
;
585 if ( old_data
.dsize
)
587 if ( unpack_pjob( old_data
.dptr
, old_data
.dsize
, &old_pjob
) != -1 )
589 pjob_store_notify( sharename
, jobid
, &old_pjob
, pjob
);
590 free_nt_devicemode( &old_pjob
.nt_devmode
);
595 pjob_store_notify( sharename
, jobid
, NULL
, pjob
);
600 SAFE_FREE( old_data
.dptr
);
606 /****************************************************************************
607 Remove a job structure from the database.
608 ****************************************************************************/
610 void pjob_delete(const char* sharename
, uint32 jobid
)
613 struct printjob
*pjob
;
614 uint32 job_status
= 0;
615 struct tdb_print_db
*pdb
;
617 pdb
= get_print_db_byname( sharename
);
622 pjob
= print_job_find( sharename
, jobid
);
625 DEBUG(5, ("pjob_delete: we were asked to delete nonexistent job %u\n",
626 (unsigned int)jobid
));
627 release_print_db(pdb
);
631 /* We must cycle through JOB_STATUS_DELETING and
632 JOB_STATUS_DELETED for the port monitor to delete the job
635 job_status
= JOB_STATUS_DELETING
|JOB_STATUS_DELETED
;
636 notify_job_status(sharename
, jobid
, job_status
);
638 /* Remove from printing.tdb */
640 tdb_delete(pdb
->tdb
, print_key(jobid
, &tmp
));
641 remove_from_jobs_changed(sharename
, jobid
);
642 release_print_db( pdb
);
643 rap_jobid_delete(sharename
, jobid
);
646 /****************************************************************************
647 Parse a file name from the system spooler to generate a jobid.
648 ****************************************************************************/
650 static uint32
print_parse_jobid(char *fname
)
654 if (strncmp(fname
,PRINT_SPOOL_PREFIX
,strlen(PRINT_SPOOL_PREFIX
)) != 0)
656 fname
+= strlen(PRINT_SPOOL_PREFIX
);
662 return (uint32
)jobid
;
665 /****************************************************************************
666 List a unix job in the print database.
667 ****************************************************************************/
669 static void print_unix_job(const char *sharename
, print_queue_struct
*q
, uint32 jobid
)
671 struct printjob pj
, *old_pj
;
673 if (jobid
== (uint32
)-1)
674 jobid
= q
->job
+ UNIX_JOB_START
;
676 /* Preserve the timestamp on an existing unix print job */
678 old_pj
= print_job_find(sharename
, jobid
);
685 pj
.starttime
= old_pj
? old_pj
->starttime
: q
->time
;
686 pj
.status
= q
->status
;
689 fstrcpy(pj
.filename
, old_pj
? old_pj
->filename
: "");
690 if (jobid
< UNIX_JOB_START
) {
692 fstrcpy(pj
.jobname
, old_pj
? old_pj
->jobname
: "Remote Downlevel Document");
695 fstrcpy(pj
.jobname
, old_pj
? old_pj
->jobname
: q
->fs_file
);
697 fstrcpy(pj
.user
, old_pj
? old_pj
->user
: q
->fs_user
);
698 fstrcpy(pj
.queuename
, old_pj
? old_pj
->queuename
: sharename
);
700 pjob_store(sharename
, jobid
, &pj
);
704 struct traverse_struct
{
705 print_queue_struct
*queue
;
706 int qcount
, snum
, maxcount
, total_jobs
;
707 const char *sharename
;
709 const char *lprm_command
;
710 struct printif
*print_if
;
713 /****************************************************************************
714 Utility fn to delete any jobs that are no longer active.
715 ****************************************************************************/
717 static int traverse_fn_delete(TDB_CONTEXT
*t
, TDB_DATA key
, TDB_DATA data
, void *state
)
719 struct traverse_struct
*ts
= (struct traverse_struct
*)state
;
720 struct printjob pjob
;
724 if ( key
.dsize
!= sizeof(jobid
) )
727 jobid
= IVAL(key
.dptr
, 0);
728 if ( unpack_pjob( data
.dptr
, data
.dsize
, &pjob
) == -1 )
730 free_nt_devicemode( &pjob
.nt_devmode
);
734 /* remove a unix job if it isn't in the system queue any more */
736 for (i
=0;i
<ts
->qcount
;i
++) {
737 uint32 u_jobid
= (ts
->queue
[i
].job
+ UNIX_JOB_START
);
738 if (jobid
== u_jobid
)
741 if (i
== ts
->qcount
) {
742 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !smbjob\n",
743 (unsigned int)jobid
));
744 pjob_delete(ts
->sharename
, jobid
);
748 /* need to continue the the bottom of the function to
749 save the correct attributes */
752 /* maybe it hasn't been spooled yet */
754 /* if a job is not spooled and the process doesn't
755 exist then kill it. This cleans up after smbd
757 if (!process_exists_by_pid(pjob
.pid
)) {
758 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !process_exists (%u)\n",
759 (unsigned int)jobid
, (unsigned int)pjob
.pid
));
760 pjob_delete(ts
->sharename
, jobid
);
766 /* this check only makes sense for jobs submitted from Windows clients */
769 for (i
=0;i
<ts
->qcount
;i
++) {
772 if ( pjob
.status
== LPQ_DELETED
)
775 curr_jobid
= print_parse_jobid(ts
->queue
[i
].fs_file
);
777 if (jobid
== curr_jobid
) {
779 /* try to clean up any jobs that need to be deleted */
781 if ( pjob
.status
== LPQ_DELETING
) {
784 result
= (*(ts
->print_if
->job_delete
))(
785 ts
->sharename
, ts
->lprm_command
, &pjob
);
788 /* if we can't delete, then reset the job status */
789 pjob
.status
= LPQ_QUEUED
;
790 pjob_store(ts
->sharename
, jobid
, &pjob
);
793 /* if we deleted the job, the remove the tdb record */
794 pjob_delete(ts
->sharename
, jobid
);
795 pjob
.status
= LPQ_DELETED
;
805 /* The job isn't in the system queue - we have to assume it has
806 completed, so delete the database entry. */
808 if (i
== ts
->qcount
) {
810 /* A race can occur between the time a job is spooled and
811 when it appears in the lpq output. This happens when
812 the job is added to printing.tdb when another smbd
813 running print_queue_update() has completed a lpq and
814 is currently traversing the printing tdb and deleting jobs.
815 Don't delete the job if it was submitted after the lpq_time. */
817 if (pjob
.starttime
< ts
->lpq_time
) {
818 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to pjob.starttime (%u) < ts->lpq_time (%u)\n",
820 (unsigned int)pjob
.starttime
,
821 (unsigned int)ts
->lpq_time
));
822 pjob_delete(ts
->sharename
, jobid
);
828 /* Save the pjob attributes we will store.
829 FIXME!!! This is the only place where queue->job
830 represents the SMB jobid --jerry */
832 ts
->queue
[i
].job
= jobid
;
833 ts
->queue
[i
].size
= pjob
.size
;
834 ts
->queue
[i
].page_count
= pjob
.page_count
;
835 ts
->queue
[i
].status
= pjob
.status
;
836 ts
->queue
[i
].priority
= 1;
837 ts
->queue
[i
].time
= pjob
.starttime
;
838 fstrcpy(ts
->queue
[i
].fs_user
, pjob
.user
);
839 fstrcpy(ts
->queue
[i
].fs_file
, pjob
.jobname
);
846 /****************************************************************************
847 Check if the print queue has been updated recently enough.
848 ****************************************************************************/
850 static void print_cache_flush(const char *sharename
)
853 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
857 slprintf(key
, sizeof(key
)-1, "CACHE/%s", sharename
);
858 tdb_store_int32(pdb
->tdb
, key
, -1);
859 release_print_db(pdb
);
862 /****************************************************************************
863 Check if someone already thinks they are doing the update.
864 ****************************************************************************/
866 static pid_t
get_updating_pid(const char *sharename
)
871 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
875 slprintf(keystr
, sizeof(keystr
)-1, "UPDATING/%s", sharename
);
876 key
= string_tdb_data(keystr
);
878 data
= tdb_fetch(pdb
->tdb
, key
);
879 release_print_db(pdb
);
880 if (!data
.dptr
|| data
.dsize
!= sizeof(pid_t
)) {
881 SAFE_FREE(data
.dptr
);
885 updating_pid
= IVAL(data
.dptr
, 0);
886 SAFE_FREE(data
.dptr
);
888 if (process_exists_by_pid(updating_pid
))
894 /****************************************************************************
895 Set the fact that we're doing the update, or have finished doing the update
897 ****************************************************************************/
899 static void set_updating_pid(const fstring sharename
, bool updating
)
904 pid_t updating_pid
= sys_getpid();
907 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
912 slprintf(keystr
, sizeof(keystr
)-1, "UPDATING/%s", sharename
);
913 key
= string_tdb_data(keystr
);
915 DEBUG(5, ("set_updating_pid: %s updating lpq cache for print share %s\n",
916 updating
? "" : "not ",
920 tdb_delete(pdb
->tdb
, key
);
921 release_print_db(pdb
);
925 SIVAL( buffer
, 0, updating_pid
);
927 data
.dsize
= 4; /* we always assume this is a 4 byte value */
929 tdb_store(pdb
->tdb
, key
, data
, TDB_REPLACE
);
930 release_print_db(pdb
);
933 /****************************************************************************
934 Sort print jobs by submittal time.
935 ****************************************************************************/
937 static int printjob_comp(print_queue_struct
*j1
, print_queue_struct
*j2
)
948 /* Sort on job start time */
950 if (j1
->time
== j2
->time
)
952 return (j1
->time
> j2
->time
) ? 1 : -1;
955 /****************************************************************************
956 Store the sorted queue representation for later portmon retrieval.
958 ****************************************************************************/
960 static void store_queue_struct(struct tdb_print_db
*pdb
, struct traverse_struct
*pts
)
963 int max_reported_jobs
= lp_max_reported_jobs(pts
->snum
);
964 print_queue_struct
*queue
= pts
->queue
;
969 if (max_reported_jobs
&& (max_reported_jobs
< pts
->qcount
))
970 pts
->qcount
= max_reported_jobs
;
973 /* Work out the size. */
975 data
.dsize
+= tdb_pack(NULL
, 0, "d", qcount
);
977 for (i
= 0; i
< pts
->qcount
; i
++) {
978 if ( queue
[i
].status
== LPQ_DELETED
)
982 data
.dsize
+= tdb_pack(NULL
, 0, "ddddddff",
983 (uint32
)queue
[i
].job
,
984 (uint32
)queue
[i
].size
,
985 (uint32
)queue
[i
].page_count
,
986 (uint32
)queue
[i
].status
,
987 (uint32
)queue
[i
].priority
,
988 (uint32
)queue
[i
].time
,
993 if ((data
.dptr
= (uint8
*)SMB_MALLOC(data
.dsize
)) == NULL
)
997 len
+= tdb_pack(data
.dptr
+ len
, data
.dsize
- len
, "d", qcount
);
998 for (i
= 0; i
< pts
->qcount
; i
++) {
999 if ( queue
[i
].status
== LPQ_DELETED
)
1002 len
+= tdb_pack(data
.dptr
+ len
, data
.dsize
- len
, "ddddddff",
1003 (uint32
)queue
[i
].job
,
1004 (uint32
)queue
[i
].size
,
1005 (uint32
)queue
[i
].page_count
,
1006 (uint32
)queue
[i
].status
,
1007 (uint32
)queue
[i
].priority
,
1008 (uint32
)queue
[i
].time
,
1013 tdb_store(pdb
->tdb
, string_tdb_data("INFO/linear_queue_array"), data
,
1015 SAFE_FREE(data
.dptr
);
1019 static TDB_DATA
get_jobs_changed_data(struct tdb_print_db
*pdb
)
1025 data
= tdb_fetch(pdb
->tdb
, string_tdb_data("INFO/jobs_changed"));
1026 if (data
.dptr
== NULL
|| data
.dsize
== 0 || (data
.dsize
% 4 != 0)) {
1027 SAFE_FREE(data
.dptr
);
1034 static void check_job_changed(const char *sharename
, TDB_DATA data
, uint32 jobid
)
1037 unsigned int job_count
= data
.dsize
/ 4;
1039 for (i
= 0; i
< job_count
; i
++) {
1042 ch_jobid
= IVAL(data
.dptr
, i
*4);
1043 if (ch_jobid
== jobid
)
1044 remove_from_jobs_changed(sharename
, jobid
);
1048 /****************************************************************************
1049 Check if the print queue has been updated recently enough.
1050 ****************************************************************************/
1052 static bool print_cache_expired(const char *sharename
, bool check_pending
)
1055 time_t last_qscan_time
, time_now
= time(NULL
);
1056 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1057 bool result
= False
;
1062 snprintf(key
, sizeof(key
), "CACHE/%s", sharename
);
1063 last_qscan_time
= (time_t)tdb_fetch_int32(pdb
->tdb
, key
);
1066 * Invalidate the queue for 3 reasons.
1067 * (1). last queue scan time == -1.
1068 * (2). Current time - last queue scan time > allowed cache time.
1069 * (3). last queue scan time > current time + MAX_CACHE_VALID_TIME (1 hour by default).
1070 * This last test picks up machines for which the clock has been moved
1071 * forward, an lpq scan done and then the clock moved back. Otherwise
1072 * that last lpq scan would stay around for a loooong loooong time... :-). JRA.
1075 if (last_qscan_time
== ((time_t)-1)
1076 || (time_now
- last_qscan_time
) >= lp_lpqcachetime()
1077 || last_qscan_time
> (time_now
+ MAX_CACHE_VALID_TIME
))
1080 time_t msg_pending_time
;
1082 DEBUG(4, ("print_cache_expired: cache expired for queue %s "
1083 "(last_qscan_time = %d, time now = %d, qcachetime = %d)\n",
1084 sharename
, (int)last_qscan_time
, (int)time_now
,
1085 (int)lp_lpqcachetime() ));
1087 /* check if another smbd has already sent a message to update the
1088 queue. Give the pending message one minute to clear and
1089 then send another message anyways. Make sure to check for
1090 clocks that have been run forward and then back again. */
1092 snprintf(key
, sizeof(key
), "MSG_PENDING/%s", sharename
);
1095 && tdb_fetch_uint32( pdb
->tdb
, key
, &u
)
1096 && (msg_pending_time
=u
) > 0
1097 && msg_pending_time
<= time_now
1098 && (time_now
- msg_pending_time
) < 60 )
1100 DEBUG(4,("print_cache_expired: message already pending for %s. Accepting cache\n",
1109 release_print_db(pdb
);
1113 /****************************************************************************
1114 main work for updating the lpq cahe for a printer queue
1115 ****************************************************************************/
1117 static void print_queue_update_internal( const char *sharename
,
1118 struct printif
*current_printif
,
1119 char *lpq_command
, char *lprm_command
)
1122 print_queue_struct
*queue
= NULL
;
1123 print_status_struct status
;
1124 print_status_struct old_status
;
1125 struct printjob
*pjob
;
1126 struct traverse_struct tstruct
;
1129 fstring keystr
, cachestr
;
1130 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1136 DEBUG(5,("print_queue_update_internal: printer = %s, type = %d, lpq command = [%s]\n",
1137 sharename
, current_printif
->type
, lpq_command
));
1140 * Update the cache time FIRST ! Stops others even
1141 * attempting to get the lock and doing this
1142 * if the lpq takes a long time.
1145 slprintf(cachestr
, sizeof(cachestr
)-1, "CACHE/%s", sharename
);
1146 tdb_store_int32(pdb
->tdb
, cachestr
, (int)time(NULL
));
1148 /* get the current queue using the appropriate interface */
1149 ZERO_STRUCT(status
);
1151 qcount
= (*(current_printif
->queue_get
))(sharename
,
1152 current_printif
->type
,
1153 lpq_command
, &queue
, &status
);
1155 DEBUG(3, ("print_queue_update_internal: %d job%s in queue for %s\n",
1156 qcount
, (qcount
!= 1) ? "s" : "", sharename
));
1158 /* Sort the queue by submission time otherwise they are displayed
1161 qsort(queue
, qcount
, sizeof(print_queue_struct
),
1162 QSORT_CAST(printjob_comp
));
1165 any job in the internal database that is marked as spooled
1166 and doesn't exist in the system queue is considered finished
1167 and removed from the database
1169 any job in the system database but not in the internal database
1170 is added as a unix job
1172 fill in any system job numbers as we go
1175 jcdata
= get_jobs_changed_data(pdb
);
1177 for (i
=0; i
<qcount
; i
++) {
1178 uint32 jobid
= print_parse_jobid(queue
[i
].fs_file
);
1180 if (jobid
== (uint32
)-1) {
1181 /* assume its a unix print job */
1182 print_unix_job(sharename
, &queue
[i
], jobid
);
1186 /* we have an active SMB print job - update its status */
1187 pjob
= print_job_find(sharename
, jobid
);
1189 /* err, somethings wrong. Probably smbd was restarted
1190 with jobs in the queue. All we can do is treat them
1191 like unix jobs. Pity. */
1192 print_unix_job(sharename
, &queue
[i
], jobid
);
1196 pjob
->sysjob
= queue
[i
].job
;
1198 /* don't reset the status on jobs to be deleted */
1200 if ( pjob
->status
!= LPQ_DELETING
)
1201 pjob
->status
= queue
[i
].status
;
1203 pjob_store(sharename
, jobid
, pjob
);
1205 check_job_changed(sharename
, jcdata
, jobid
);
1208 SAFE_FREE(jcdata
.dptr
);
1210 /* now delete any queued entries that don't appear in the
1212 tstruct
.queue
= queue
;
1213 tstruct
.qcount
= qcount
;
1215 tstruct
.total_jobs
= 0;
1216 tstruct
.lpq_time
= time(NULL
);
1217 tstruct
.sharename
= sharename
;
1218 tstruct
.lprm_command
= lprm_command
;
1219 tstruct
.print_if
= current_printif
;
1221 tdb_traverse(pdb
->tdb
, traverse_fn_delete
, (void *)&tstruct
);
1223 /* Store the linearised queue, max jobs only. */
1224 store_queue_struct(pdb
, &tstruct
);
1226 SAFE_FREE(tstruct
.queue
);
1228 DEBUG(10,("print_queue_update_internal: printer %s INFO/total_jobs = %d\n",
1229 sharename
, tstruct
.total_jobs
));
1231 tdb_store_int32(pdb
->tdb
, "INFO/total_jobs", tstruct
.total_jobs
);
1233 get_queue_status(sharename
, &old_status
);
1234 if (old_status
.qcount
!= qcount
)
1235 DEBUG(10,("print_queue_update_internal: queue status change %d jobs -> %d jobs for printer %s\n",
1236 old_status
.qcount
, qcount
, sharename
));
1238 /* store the new queue status structure */
1239 slprintf(keystr
, sizeof(keystr
)-1, "STATUS/%s", sharename
);
1240 key
= string_tdb_data(keystr
);
1242 status
.qcount
= qcount
;
1243 data
.dptr
= (uint8
*)&status
;
1244 data
.dsize
= sizeof(status
);
1245 tdb_store(pdb
->tdb
, key
, data
, TDB_REPLACE
);
1248 * Update the cache time again. We want to do this call
1249 * as little as possible...
1252 slprintf(keystr
, sizeof(keystr
)-1, "CACHE/%s", sharename
);
1253 tdb_store_int32(pdb
->tdb
, keystr
, (int32
)time(NULL
));
1255 /* clear the msg pending record for this queue */
1257 snprintf(keystr
, sizeof(keystr
), "MSG_PENDING/%s", sharename
);
1259 if ( !tdb_store_uint32( pdb
->tdb
, keystr
, 0 ) ) {
1260 /* log a message but continue on */
1262 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1266 release_print_db( pdb
);
1271 /****************************************************************************
1272 Update the internal database from the system print queue for a queue.
1273 obtain a lock on the print queue before proceeding (needed when mutiple
1274 smbd processes maytry to update the lpq cache concurrently).
1275 ****************************************************************************/
1277 static void print_queue_update_with_lock( const char *sharename
,
1278 struct printif
*current_printif
,
1279 char *lpq_command
, char *lprm_command
)
1282 struct tdb_print_db
*pdb
;
1284 DEBUG(5,("print_queue_update_with_lock: printer share = %s\n", sharename
));
1285 pdb
= get_print_db_byname(sharename
);
1289 if ( !print_cache_expired(sharename
, False
) ) {
1290 DEBUG(5,("print_queue_update_with_lock: print cache for %s is still ok\n", sharename
));
1291 release_print_db(pdb
);
1296 * Check to see if someone else is doing this update.
1297 * This is essentially a mutex on the update.
1300 if (get_updating_pid(sharename
) != -1) {
1301 release_print_db(pdb
);
1305 /* Lock the queue for the database update */
1307 slprintf(keystr
, sizeof(keystr
) - 1, "LOCK/%s", sharename
);
1308 /* Only wait 10 seconds for this. */
1309 if (tdb_lock_bystring_with_timeout(pdb
->tdb
, keystr
, 10) == -1) {
1310 DEBUG(0,("print_queue_update_with_lock: Failed to lock printer %s database\n", sharename
));
1311 release_print_db(pdb
);
1316 * Ensure that no one else got in here.
1317 * If the updating pid is still -1 then we are
1321 if (get_updating_pid(sharename
) != -1) {
1323 * Someone else is doing the update, exit.
1325 tdb_unlock_bystring(pdb
->tdb
, keystr
);
1326 release_print_db(pdb
);
1331 * We're going to do the update ourselves.
1334 /* Tell others we're doing the update. */
1335 set_updating_pid(sharename
, True
);
1338 * Allow others to enter and notice we're doing
1342 tdb_unlock_bystring(pdb
->tdb
, keystr
);
1344 /* do the main work now */
1346 print_queue_update_internal( sharename
, current_printif
,
1347 lpq_command
, lprm_command
);
1349 /* Delete our pid from the db. */
1350 set_updating_pid(sharename
, False
);
1351 release_print_db(pdb
);
1354 /****************************************************************************
1355 this is the receive function of the background lpq updater
1356 ****************************************************************************/
1357 static void print_queue_receive(struct messaging_context
*msg
,
1360 struct server_id server_id
,
1364 char *lpqcommand
= NULL
, *lprmcommand
= NULL
;
1368 len
= tdb_unpack( (uint8
*)data
->data
, data
->length
, "fdPP",
1375 SAFE_FREE(lpqcommand
);
1376 SAFE_FREE(lprmcommand
);
1377 DEBUG(0,("print_queue_receive: Got invalid print queue update message\n"));
1381 print_queue_update_with_lock(sharename
,
1382 get_printer_fns_from_type((enum printing_types
)printing_type
),
1383 lpqcommand
, lprmcommand
);
1385 SAFE_FREE(lpqcommand
);
1386 SAFE_FREE(lprmcommand
);
1390 static void printing_pause_fd_handler(struct tevent_context
*ev
,
1391 struct tevent_fd
*fde
,
1396 * If pause_pipe[1] is closed it means the parent smbd
1397 * and children exited or aborted.
1399 exit_server_cleanly(NULL
);
1402 static pid_t background_lpq_updater_pid
= -1;
1404 /****************************************************************************
1405 main thread of the background lpq updater
1406 ****************************************************************************/
1407 void start_background_queue(void)
1409 /* Use local variables for this as we don't
1410 * need to save the parent side of this, just
1411 * ensure it closes when the process exits.
1415 DEBUG(3,("start_background_queue: Starting background LPQ thread\n"));
1417 if (pipe(pause_pipe
) == -1) {
1418 DEBUG(5,("start_background_queue: cannot create pipe. %s\n", strerror(errno
) ));
1422 background_lpq_updater_pid
= sys_fork();
1424 if (background_lpq_updater_pid
== -1) {
1425 DEBUG(5,("start_background_queue: background LPQ thread failed to start. %s\n", strerror(errno
) ));
1429 if(background_lpq_updater_pid
== 0) {
1430 struct tevent_fd
*fde
;
1434 DEBUG(5,("start_background_queue: background LPQ thread started\n"));
1436 close(pause_pipe
[0]);
1439 if (!NT_STATUS_IS_OK(reinit_after_fork(smbd_messaging_context(),
1440 smbd_event_context(),
1442 DEBUG(0,("reinit_after_fork() failed\n"));
1443 smb_panic("reinit_after_fork() failed");
1446 smbd_setup_sig_term_handler();
1447 smbd_setup_sig_hup_handler();
1449 claim_connection( NULL
, "smbd lpq backend",
1450 FLAG_MSG_GENERAL
|FLAG_MSG_SMBD
|FLAG_MSG_PRINT_GENERAL
);
1452 if (!locking_init()) {
1456 messaging_register(smbd_messaging_context(), NULL
,
1457 MSG_PRINTER_UPDATE
, print_queue_receive
);
1459 fde
= tevent_add_fd(smbd_event_context(), smbd_event_context(),
1460 pause_pipe
[1], TEVENT_FD_READ
,
1461 printing_pause_fd_handler
,
1464 DEBUG(0,("tevent_add_fd() failed for pause_pipe\n"));
1465 smb_panic("tevent_add_fd() failed for pause_pipe");
1468 DEBUG(5,("start_background_queue: background LPQ thread waiting for messages\n"));
1469 ret
= tevent_loop_wait(smbd_event_context());
1470 /* should not be reached */
1471 DEBUG(0,("background_queue: tevent_loop_wait() exited with %d - %s\n",
1472 ret
, (ret
== 0) ? "out of events" : strerror(errno
)));
1476 close(pause_pipe
[1]);
1479 /****************************************************************************
1480 update the internal database from the system print queue for a queue
1481 ****************************************************************************/
1483 static void print_queue_update(int snum
, bool force
)
1487 char *lpqcommand
= NULL
;
1488 char *lprmcommand
= NULL
;
1489 uint8
*buffer
= NULL
;
1492 struct tdb_print_db
*pdb
;
1494 struct printif
*current_printif
;
1495 TALLOC_CTX
*ctx
= talloc_tos();
1497 fstrcpy( sharename
, lp_const_servicename(snum
));
1499 /* don't strip out characters like '$' from the printername */
1501 lpqcommand
= talloc_string_sub2(ctx
,
1502 lp_lpqcommand(snum
),
1505 false, false, false);
1509 lpqcommand
= talloc_sub_advanced(ctx
,
1510 lp_servicename(snum
),
1511 current_user_info
.unix_name
,
1513 current_user
.ut
.gid
,
1514 get_current_username(),
1515 current_user_info
.domain
,
1521 lprmcommand
= talloc_string_sub2(ctx
,
1522 lp_lprmcommand(snum
),
1525 false, false, false);
1529 lprmcommand
= talloc_sub_advanced(ctx
,
1530 lp_servicename(snum
),
1531 current_user_info
.unix_name
,
1533 current_user
.ut
.gid
,
1534 get_current_username(),
1535 current_user_info
.domain
,
1542 * Make sure that the background queue process exists.
1543 * Otherwise just do the update ourselves
1546 if ( force
|| background_lpq_updater_pid
== -1 ) {
1547 DEBUG(4,("print_queue_update: updating queue [%s] myself\n", sharename
));
1548 current_printif
= get_printer_fns( snum
);
1549 print_queue_update_with_lock( sharename
, current_printif
, lpqcommand
, lprmcommand
);
1554 type
= lp_printing(snum
);
1556 /* get the length */
1558 len
= tdb_pack( NULL
, 0, "fdPP",
1564 buffer
= SMB_XMALLOC_ARRAY( uint8
, len
);
1566 /* now pack the buffer */
1567 newlen
= tdb_pack( buffer
, len
, "fdPP",
1573 SMB_ASSERT( newlen
== len
);
1575 DEBUG(10,("print_queue_update: Sending message -> printer = %s, "
1576 "type = %d, lpq command = [%s] lprm command = [%s]\n",
1577 sharename
, type
, lpqcommand
, lprmcommand
));
1579 /* here we set a msg pending record for other smbd processes
1580 to throttle the number of duplicate print_queue_update msgs
1583 pdb
= get_print_db_byname(sharename
);
1589 snprintf(key
, sizeof(key
), "MSG_PENDING/%s", sharename
);
1591 if ( !tdb_store_uint32( pdb
->tdb
, key
, time(NULL
) ) ) {
1592 /* log a message but continue on */
1594 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1598 release_print_db( pdb
);
1600 /* finally send the message */
1602 messaging_send_buf(smbd_messaging_context(),
1603 pid_to_procid(background_lpq_updater_pid
),
1604 MSG_PRINTER_UPDATE
, (uint8
*)buffer
, len
);
1606 SAFE_FREE( buffer
);
1611 /****************************************************************************
1612 Create/Update an entry in the print tdb that will allow us to send notify
1613 updates only to interested smbd's.
1614 ****************************************************************************/
1616 bool print_notify_register_pid(int snum
)
1619 struct tdb_print_db
*pdb
= NULL
;
1620 TDB_CONTEXT
*tdb
= NULL
;
1621 const char *printername
;
1622 uint32 mypid
= (uint32
)sys_getpid();
1626 /* if (snum == -1), then the change notify request was
1627 on a print server handle and we need to register on
1632 int num_services
= lp_numservices();
1635 for ( idx
=0; idx
<num_services
; idx
++ ) {
1636 if (lp_snum_ok(idx
) && lp_print_ok(idx
) )
1637 print_notify_register_pid(idx
);
1642 else /* register for a specific printer */
1644 printername
= lp_const_servicename(snum
);
1645 pdb
= get_print_db_byname(printername
);
1651 if (tdb_lock_bystring_with_timeout(tdb
, NOTIFY_PID_LIST_KEY
, 10) == -1) {
1652 DEBUG(0,("print_notify_register_pid: Failed to lock printer %s\n",
1655 release_print_db(pdb
);
1659 data
= get_printer_notify_pid_list( tdb
, printername
, True
);
1661 /* Add ourselves and increase the refcount. */
1663 for (i
= 0; i
< data
.dsize
; i
+= 8) {
1664 if (IVAL(data
.dptr
,i
) == mypid
) {
1665 uint32 new_refcount
= IVAL(data
.dptr
, i
+4) + 1;
1666 SIVAL(data
.dptr
, i
+4, new_refcount
);
1671 if (i
== data
.dsize
) {
1672 /* We weren't in the list. Realloc. */
1673 data
.dptr
= (uint8
*)SMB_REALLOC(data
.dptr
, data
.dsize
+ 8);
1675 DEBUG(0,("print_notify_register_pid: Relloc fail for printer %s\n",
1680 SIVAL(data
.dptr
,data
.dsize
- 8,mypid
);
1681 SIVAL(data
.dptr
,data
.dsize
- 4,1); /* Refcount. */
1684 /* Store back the record. */
1685 if (tdb_store_bystring(tdb
, NOTIFY_PID_LIST_KEY
, data
, TDB_REPLACE
) == -1) {
1686 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1687 list for printer %s\n", printername
));
1695 tdb_unlock_bystring(tdb
, NOTIFY_PID_LIST_KEY
);
1697 release_print_db(pdb
);
1698 SAFE_FREE(data
.dptr
);
1702 /****************************************************************************
1703 Update an entry in the print tdb that will allow us to send notify
1704 updates only to interested smbd's.
1705 ****************************************************************************/
1707 bool print_notify_deregister_pid(int snum
)
1710 struct tdb_print_db
*pdb
= NULL
;
1711 TDB_CONTEXT
*tdb
= NULL
;
1712 const char *printername
;
1713 uint32 mypid
= (uint32
)sys_getpid();
1717 /* if ( snum == -1 ), we are deregister a print server handle
1718 which means to deregister on all print queues */
1722 int num_services
= lp_numservices();
1725 for ( idx
=0; idx
<num_services
; idx
++ ) {
1726 if ( lp_snum_ok(idx
) && lp_print_ok(idx
) )
1727 print_notify_deregister_pid(idx
);
1732 else /* deregister a specific printer */
1734 printername
= lp_const_servicename(snum
);
1735 pdb
= get_print_db_byname(printername
);
1741 if (tdb_lock_bystring_with_timeout(tdb
, NOTIFY_PID_LIST_KEY
, 10) == -1) {
1742 DEBUG(0,("print_notify_register_pid: Failed to lock \
1743 printer %s database\n", printername
));
1745 release_print_db(pdb
);
1749 data
= get_printer_notify_pid_list( tdb
, printername
, True
);
1751 /* Reduce refcount. Remove ourselves if zero. */
1753 for (i
= 0; i
< data
.dsize
; ) {
1754 if (IVAL(data
.dptr
,i
) == mypid
) {
1755 uint32 refcount
= IVAL(data
.dptr
, i
+4);
1759 if (refcount
== 0) {
1760 if (data
.dsize
- i
> 8)
1761 memmove( &data
.dptr
[i
], &data
.dptr
[i
+8], data
.dsize
- i
- 8);
1765 SIVAL(data
.dptr
, i
+4, refcount
);
1771 if (data
.dsize
== 0)
1772 SAFE_FREE(data
.dptr
);
1774 /* Store back the record. */
1775 if (tdb_store_bystring(tdb
, NOTIFY_PID_LIST_KEY
, data
, TDB_REPLACE
) == -1) {
1776 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1777 list for printer %s\n", printername
));
1785 tdb_unlock_bystring(tdb
, NOTIFY_PID_LIST_KEY
);
1787 release_print_db(pdb
);
1788 SAFE_FREE(data
.dptr
);
1792 /****************************************************************************
1793 Check if a jobid is valid. It is valid if it exists in the database.
1794 ****************************************************************************/
1796 bool print_job_exists(const char* sharename
, uint32 jobid
)
1798 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1804 ret
= tdb_exists(pdb
->tdb
, print_key(jobid
, &tmp
));
1805 release_print_db(pdb
);
1809 /****************************************************************************
1810 Give the fd used for a jobid.
1811 ****************************************************************************/
1813 int print_job_fd(const char* sharename
, uint32 jobid
)
1815 struct printjob
*pjob
= print_job_find(sharename
, jobid
);
1818 /* don't allow another process to get this info - it is meaningless */
1819 if (pjob
->pid
!= sys_getpid())
1824 /****************************************************************************
1825 Give the filename used for a jobid.
1826 Only valid for the process doing the spooling and when the job
1827 has not been spooled.
1828 ****************************************************************************/
1830 char *print_job_fname(const char* sharename
, uint32 jobid
)
1832 struct printjob
*pjob
= print_job_find(sharename
, jobid
);
1833 if (!pjob
|| pjob
->spooled
|| pjob
->pid
!= sys_getpid())
1835 return pjob
->filename
;
1839 /****************************************************************************
1840 Give the filename used for a jobid.
1841 Only valid for the process doing the spooling and when the job
1842 has not been spooled.
1843 ****************************************************************************/
1845 NT_DEVICEMODE
*print_job_devmode(const char* sharename
, uint32 jobid
)
1847 struct printjob
*pjob
= print_job_find(sharename
, jobid
);
1852 return pjob
->nt_devmode
;
1855 /****************************************************************************
1856 Set the place in the queue for a job.
1857 ****************************************************************************/
1859 bool print_job_set_place(const char *sharename
, uint32 jobid
, int place
)
1861 DEBUG(2,("print_job_set_place not implemented yet\n"));
1865 /****************************************************************************
1866 Set the name of a job. Only possible for owner.
1867 ****************************************************************************/
1869 bool print_job_set_name(const char *sharename
, uint32 jobid
, char *name
)
1871 struct printjob
*pjob
;
1873 pjob
= print_job_find(sharename
, jobid
);
1874 if (!pjob
|| pjob
->pid
!= sys_getpid())
1877 fstrcpy(pjob
->jobname
, name
);
1878 return pjob_store(sharename
, jobid
, pjob
);
1881 /***************************************************************************
1882 Remove a jobid from the 'jobs changed' list.
1883 ***************************************************************************/
1885 static bool remove_from_jobs_changed(const char* sharename
, uint32 jobid
)
1887 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1889 size_t job_count
, i
;
1891 bool gotlock
= False
;
1899 key
= string_tdb_data("INFO/jobs_changed");
1901 if (tdb_chainlock_with_timeout(pdb
->tdb
, key
, 5) == -1)
1906 data
= tdb_fetch(pdb
->tdb
, key
);
1908 if (data
.dptr
== NULL
|| data
.dsize
== 0 || (data
.dsize
% 4 != 0))
1911 job_count
= data
.dsize
/ 4;
1912 for (i
= 0; i
< job_count
; i
++) {
1915 ch_jobid
= IVAL(data
.dptr
, i
*4);
1916 if (ch_jobid
== jobid
) {
1917 if (i
< job_count
-1 )
1918 memmove(data
.dptr
+ (i
*4), data
.dptr
+ (i
*4) + 4, (job_count
- i
- 1)*4 );
1920 if (tdb_store(pdb
->tdb
, key
, data
, TDB_REPLACE
) == -1)
1930 tdb_chainunlock(pdb
->tdb
, key
);
1931 SAFE_FREE(data
.dptr
);
1932 release_print_db(pdb
);
1934 DEBUG(10,("remove_from_jobs_changed: removed jobid %u\n", (unsigned int)jobid
));
1936 DEBUG(10,("remove_from_jobs_changed: Failed to remove jobid %u\n", (unsigned int)jobid
));
1940 /****************************************************************************
1941 Delete a print job - don't update queue.
1942 ****************************************************************************/
1944 static bool print_job_delete1(int snum
, uint32 jobid
)
1946 const char* sharename
= lp_const_servicename(snum
);
1947 struct printjob
*pjob
= print_job_find(sharename
, jobid
);
1949 struct printif
*current_printif
= get_printer_fns( snum
);
1955 * If already deleting just return.
1958 if (pjob
->status
== LPQ_DELETING
)
1961 /* Hrm - we need to be able to cope with deleting a job before it
1962 has reached the spooler. Just mark it as LPQ_DELETING and
1963 let the print_queue_update() code rmeove the record */
1966 if (pjob
->sysjob
== -1) {
1967 DEBUG(5, ("attempt to delete job %u not seen by lpr\n", (unsigned int)jobid
));
1970 /* Set the tdb entry to be deleting. */
1972 pjob
->status
= LPQ_DELETING
;
1973 pjob_store(sharename
, jobid
, pjob
);
1975 if (pjob
->spooled
&& pjob
->sysjob
!= -1)
1977 result
= (*(current_printif
->job_delete
))(
1979 lp_lprmcommand(snum
),
1982 /* Delete the tdb entry if the delete succeeded or the job hasn't
1986 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1991 pjob_delete(sharename
, jobid
);
1992 /* Ensure we keep a rough count of the number of total jobs... */
1993 tdb_change_int32_atomic(pdb
->tdb
, "INFO/total_jobs", &njobs
, -1);
1994 release_print_db(pdb
);
1998 remove_from_jobs_changed( sharename
, jobid
);
2000 return (result
== 0);
2003 /****************************************************************************
2004 Return true if the current user owns the print job.
2005 ****************************************************************************/
2007 static bool is_owner(struct auth_serversupplied_info
*server_info
,
2008 const char *servicename
,
2011 struct printjob
*pjob
= print_job_find(servicename
, jobid
);
2013 if (!pjob
|| !server_info
)
2016 return strequal(pjob
->user
, server_info
->sanitized_username
);
2019 /****************************************************************************
2021 ****************************************************************************/
2023 bool print_job_delete(struct auth_serversupplied_info
*server_info
, int snum
,
2024 uint32 jobid
, WERROR
*errcode
)
2026 const char* sharename
= lp_const_servicename( snum
);
2027 struct printjob
*pjob
;
2033 owner
= is_owner(server_info
, lp_const_servicename(snum
), jobid
);
2035 /* Check access against security descriptor or whether the user
2039 !print_access_check(server_info
, snum
, JOB_ACCESS_ADMINISTER
)) {
2040 DEBUG(3, ("delete denied by security descriptor\n"));
2041 *errcode
= WERR_ACCESS_DENIED
;
2043 /* BEGIN_ADMIN_LOG */
2044 sys_adminlog( LOG_ERR
,
2045 "Permission denied-- user not allowed to delete, \
2046 pause, or resume print job. User name: %s. Printer name: %s.",
2047 uidtoname(server_info
->utok
.uid
),
2048 PRINTERNAME(snum
) );
2055 * get the spooled filename of the print job
2056 * if this works, then the file has not been spooled
2057 * to the underlying print system. Just delete the
2058 * spool file & return.
2061 if ( (fname
= print_job_fname( sharename
, jobid
)) != NULL
)
2063 /* remove the spool file */
2064 DEBUG(10,("print_job_delete: Removing spool file [%s]\n", fname
));
2065 if ( unlink( fname
) == -1 ) {
2066 *errcode
= map_werror_from_unix(errno
);
2071 if (!print_job_delete1(snum
, jobid
)) {
2072 *errcode
= WERR_ACCESS_DENIED
;
2076 /* force update the database and say the delete failed if the
2079 print_queue_update(snum
, True
);
2081 pjob
= print_job_find(sharename
, jobid
);
2082 if ( pjob
&& (pjob
->status
!= LPQ_DELETING
) )
2083 *errcode
= WERR_ACCESS_DENIED
;
2085 return (pjob
== NULL
);
2088 /****************************************************************************
2090 ****************************************************************************/
2092 bool print_job_pause(struct auth_serversupplied_info
*server_info
, int snum
,
2093 uint32 jobid
, WERROR
*errcode
)
2095 const char* sharename
= lp_const_servicename(snum
);
2096 struct printjob
*pjob
;
2098 struct printif
*current_printif
= get_printer_fns( snum
);
2100 pjob
= print_job_find(sharename
, jobid
);
2102 if (!pjob
|| !server_info
) {
2103 DEBUG(10, ("print_job_pause: no pjob or user for jobid %u\n",
2104 (unsigned int)jobid
));
2108 if (!pjob
->spooled
|| pjob
->sysjob
== -1) {
2109 DEBUG(10, ("print_job_pause: not spooled or bad sysjob = %d for jobid %u\n",
2110 (int)pjob
->sysjob
, (unsigned int)jobid
));
2114 if (!is_owner(server_info
, lp_const_servicename(snum
), jobid
) &&
2115 !print_access_check(server_info
, snum
, JOB_ACCESS_ADMINISTER
)) {
2116 DEBUG(3, ("pause denied by security descriptor\n"));
2118 /* BEGIN_ADMIN_LOG */
2119 sys_adminlog( LOG_ERR
,
2120 "Permission denied-- user not allowed to delete, \
2121 pause, or resume print job. User name: %s. Printer name: %s.",
2122 uidtoname(server_info
->utok
.uid
),
2123 PRINTERNAME(snum
) );
2126 *errcode
= WERR_ACCESS_DENIED
;
2130 /* need to pause the spooled entry */
2131 ret
= (*(current_printif
->job_pause
))(snum
, pjob
);
2134 *errcode
= WERR_INVALID_PARAM
;
2138 /* force update the database */
2139 print_cache_flush(lp_const_servicename(snum
));
2141 /* Send a printer notify message */
2143 notify_job_status(sharename
, jobid
, JOB_STATUS_PAUSED
);
2145 /* how do we tell if this succeeded? */
2150 /****************************************************************************
2152 ****************************************************************************/
2154 bool print_job_resume(struct auth_serversupplied_info
*server_info
, int snum
,
2155 uint32 jobid
, WERROR
*errcode
)
2157 const char *sharename
= lp_const_servicename(snum
);
2158 struct printjob
*pjob
;
2160 struct printif
*current_printif
= get_printer_fns( snum
);
2162 pjob
= print_job_find(sharename
, jobid
);
2164 if (!pjob
|| !server_info
) {
2165 DEBUG(10, ("print_job_resume: no pjob or user for jobid %u\n",
2166 (unsigned int)jobid
));
2170 if (!pjob
->spooled
|| pjob
->sysjob
== -1) {
2171 DEBUG(10, ("print_job_resume: not spooled or bad sysjob = %d for jobid %u\n",
2172 (int)pjob
->sysjob
, (unsigned int)jobid
));
2176 if (!is_owner(server_info
, lp_const_servicename(snum
), jobid
) &&
2177 !print_access_check(server_info
, snum
, JOB_ACCESS_ADMINISTER
)) {
2178 DEBUG(3, ("resume denied by security descriptor\n"));
2179 *errcode
= WERR_ACCESS_DENIED
;
2181 /* BEGIN_ADMIN_LOG */
2182 sys_adminlog( LOG_ERR
,
2183 "Permission denied-- user not allowed to delete, \
2184 pause, or resume print job. User name: %s. Printer name: %s.",
2185 uidtoname(server_info
->utok
.uid
),
2186 PRINTERNAME(snum
) );
2191 ret
= (*(current_printif
->job_resume
))(snum
, pjob
);
2194 *errcode
= WERR_INVALID_PARAM
;
2198 /* force update the database */
2199 print_cache_flush(lp_const_servicename(snum
));
2201 /* Send a printer notify message */
2203 notify_job_status(sharename
, jobid
, JOB_STATUS_QUEUED
);
2208 /****************************************************************************
2209 Write to a print file.
2210 ****************************************************************************/
2212 ssize_t
print_job_write(int snum
, uint32 jobid
, const char *buf
, SMB_OFF_T pos
, size_t size
)
2214 const char* sharename
= lp_const_servicename(snum
);
2216 struct printjob
*pjob
;
2218 pjob
= print_job_find(sharename
, jobid
);
2222 /* don't allow another process to get this info - it is meaningless */
2223 if (pjob
->pid
!= sys_getpid())
2226 return_code
= write_data_at_offset(pjob
->fd
, buf
, size
, pos
);
2228 if (return_code
>0) {
2230 pjob_store(sharename
, jobid
, pjob
);
2235 /****************************************************************************
2236 Get the queue status - do not update if db is out of date.
2237 ****************************************************************************/
2239 static int get_queue_status(const char* sharename
, print_status_struct
*status
)
2243 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
2247 ZERO_STRUCTP(status
);
2254 fstr_sprintf(keystr
, "STATUS/%s", sharename
);
2255 data
= tdb_fetch(pdb
->tdb
, string_tdb_data(keystr
));
2257 if (data
.dsize
== sizeof(print_status_struct
))
2258 /* this memcpy is ok since the status struct was
2259 not packed before storing it in the tdb */
2260 memcpy(status
, data
.dptr
, sizeof(print_status_struct
));
2261 SAFE_FREE(data
.dptr
);
2264 len
= tdb_fetch_int32(pdb
->tdb
, "INFO/total_jobs");
2265 release_print_db(pdb
);
2266 return (len
== -1 ? 0 : len
);
2269 /****************************************************************************
2270 Determine the number of jobs in a queue.
2271 ****************************************************************************/
2273 int print_queue_length(int snum
, print_status_struct
*pstatus
)
2275 const char* sharename
= lp_const_servicename( snum
);
2276 print_status_struct status
;
2279 ZERO_STRUCT( status
);
2281 /* make sure the database is up to date */
2282 if (print_cache_expired(lp_const_servicename(snum
), True
))
2283 print_queue_update(snum
, False
);
2285 /* also fetch the queue status */
2286 memset(&status
, 0, sizeof(status
));
2287 len
= get_queue_status(sharename
, &status
);
2295 /***************************************************************************
2296 Allocate a jobid. Hold the lock for as short a time as possible.
2297 ***************************************************************************/
2299 static bool allocate_print_jobid(struct tdb_print_db
*pdb
, int snum
, const char *sharename
, uint32
*pjobid
)
2304 *pjobid
= (uint32
)-1;
2306 for (i
= 0; i
< 3; i
++) {
2307 /* Lock the database - only wait 20 seconds. */
2308 if (tdb_lock_bystring_with_timeout(pdb
->tdb
, "INFO/nextjob", 20) == -1) {
2309 DEBUG(0,("allocate_print_jobid: failed to lock printing database %s\n", sharename
));
2313 if (!tdb_fetch_uint32(pdb
->tdb
, "INFO/nextjob", &jobid
)) {
2314 if (tdb_error(pdb
->tdb
) != TDB_ERR_NOEXIST
) {
2315 DEBUG(0, ("allocate_print_jobid: failed to fetch INFO/nextjob for print queue %s\n",
2317 tdb_unlock_bystring(pdb
->tdb
, "INFO/nextjob");
2320 DEBUG(10,("allocate_print_jobid: no existing jobid in %s\n", sharename
));
2324 DEBUG(10,("allocate_print_jobid: read jobid %u from %s\n", jobid
, sharename
));
2326 jobid
= NEXT_JOBID(jobid
);
2328 if (tdb_store_int32(pdb
->tdb
, "INFO/nextjob", jobid
)==-1) {
2329 DEBUG(3, ("allocate_print_jobid: failed to store INFO/nextjob.\n"));
2330 tdb_unlock_bystring(pdb
->tdb
, "INFO/nextjob");
2334 /* We've finished with the INFO/nextjob lock. */
2335 tdb_unlock_bystring(pdb
->tdb
, "INFO/nextjob");
2337 if (!print_job_exists(sharename
, jobid
)) {
2340 DEBUG(10,("allocate_print_jobid: found jobid %u in %s\n", jobid
, sharename
));
2344 DEBUG(0, ("allocate_print_jobid: failed to allocate a print job for queue %s\n",
2346 /* Probably full... */
2351 /* Store a dummy placeholder. */
2357 if (tdb_store(pdb
->tdb
, print_key(jobid
, &tmp
), dum
,
2358 TDB_INSERT
) == -1) {
2359 DEBUG(3, ("allocate_print_jobid: jobid (%d) failed to store placeholder.\n",
2369 /***************************************************************************
2370 Append a jobid to the 'jobs changed' list.
2371 ***************************************************************************/
2373 static bool add_to_jobs_changed(struct tdb_print_db
*pdb
, uint32 jobid
)
2378 SIVAL(&store_jobid
, 0, jobid
);
2379 data
.dptr
= (uint8
*)&store_jobid
;
2382 DEBUG(10,("add_to_jobs_changed: Added jobid %u\n", (unsigned int)jobid
));
2384 return (tdb_append(pdb
->tdb
, string_tdb_data("INFO/jobs_changed"),
2388 /***************************************************************************
2389 Start spooling a job - return the jobid.
2390 ***************************************************************************/
2392 uint32
print_job_start(struct auth_serversupplied_info
*server_info
, int snum
,
2393 const char *jobname
, NT_DEVICEMODE
*nt_devmode
)
2397 struct printjob pjob
;
2398 const char *sharename
= lp_const_servicename(snum
);
2399 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
2407 if (!print_access_check(server_info
, snum
, PRINTER_ACCESS_USE
)) {
2408 DEBUG(3, ("print_job_start: job start denied by security descriptor\n"));
2409 release_print_db(pdb
);
2413 if (!print_time_access_check(lp_servicename(snum
))) {
2414 DEBUG(3, ("print_job_start: job start denied by time check\n"));
2415 release_print_db(pdb
);
2419 path
= lp_pathname(snum
);
2421 /* see if we have sufficient disk space */
2422 if (lp_minprintspace(snum
)) {
2423 uint64_t dspace
, dsize
;
2424 if (sys_fsusage(path
, &dspace
, &dsize
) == 0 &&
2425 dspace
< 2*(uint64_t)lp_minprintspace(snum
)) {
2426 DEBUG(3, ("print_job_start: disk space check failed.\n"));
2427 release_print_db(pdb
);
2433 /* for autoloaded printers, check that the printcap entry still exists */
2434 if (lp_autoloaded(snum
) && !pcap_printername_ok(lp_const_servicename(snum
))) {
2435 DEBUG(3, ("print_job_start: printer name %s check failed.\n", lp_const_servicename(snum
) ));
2436 release_print_db(pdb
);
2441 /* Insure the maximum queue size is not violated */
2442 if ((njobs
= print_queue_length(snum
,NULL
)) > lp_maxprintjobs(snum
)) {
2443 DEBUG(3, ("print_job_start: Queue %s number of jobs (%d) larger than max printjobs per queue (%d).\n",
2444 sharename
, njobs
, lp_maxprintjobs(snum
) ));
2445 release_print_db(pdb
);
2450 DEBUG(10,("print_job_start: Queue %s number of jobs (%d), max printjobs = %d\n",
2451 sharename
, njobs
, lp_maxprintjobs(snum
) ));
2453 if (!allocate_print_jobid(pdb
, snum
, sharename
, &jobid
))
2456 /* create the database entry */
2460 pjob
.pid
= sys_getpid();
2463 pjob
.starttime
= time(NULL
);
2464 pjob
.status
= LPQ_SPOOLING
;
2466 pjob
.spooled
= False
;
2468 pjob
.nt_devmode
= nt_devmode
;
2470 fstrcpy(pjob
.jobname
, jobname
);
2472 fstrcpy(pjob
.user
, lp_printjob_username(snum
));
2473 standard_sub_advanced(sharename
, server_info
->sanitized_username
,
2474 path
, server_info
->utok
.gid
,
2475 server_info
->sanitized_username
,
2476 pdb_get_domain(server_info
->sam_account
),
2477 pjob
.user
, sizeof(pjob
.user
)-1);
2478 /* ensure NULL termination */
2479 pjob
.user
[sizeof(pjob
.user
)-1] = '\0';
2481 fstrcpy(pjob
.queuename
, lp_const_servicename(snum
));
2483 /* we have a job entry - now create the spool file */
2484 slprintf(pjob
.filename
, sizeof(pjob
.filename
)-1, "%s/%s%.8u.XXXXXX",
2485 path
, PRINT_SPOOL_PREFIX
, (unsigned int)jobid
);
2486 pjob
.fd
= smb_mkstemp(pjob
.filename
);
2488 if (pjob
.fd
== -1) {
2489 if (errno
== EACCES
) {
2490 /* Common setup error, force a report. */
2491 DEBUG(0, ("print_job_start: insufficient permissions \
2492 to open spool file %s.\n", pjob
.filename
));
2494 /* Normal case, report at level 3 and above. */
2495 DEBUG(3, ("print_job_start: can't open spool file %s,\n", pjob
.filename
));
2496 DEBUGADD(3, ("errno = %d (%s).\n", errno
, strerror(errno
)));
2501 pjob_store(sharename
, jobid
, &pjob
);
2503 /* Update the 'jobs changed' entry used by print_queue_status. */
2504 add_to_jobs_changed(pdb
, jobid
);
2506 /* Ensure we keep a rough count of the number of total jobs... */
2507 tdb_change_int32_atomic(pdb
->tdb
, "INFO/total_jobs", &njobs
, 1);
2509 release_print_db(pdb
);
2515 pjob_delete(sharename
, jobid
);
2517 release_print_db(pdb
);
2519 DEBUG(3, ("print_job_start: returning fail. Error = %s\n", strerror(errno
) ));
2523 /****************************************************************************
2524 Update the number of pages spooled to jobid
2525 ****************************************************************************/
2527 void print_job_endpage(int snum
, uint32 jobid
)
2529 const char* sharename
= lp_const_servicename(snum
);
2530 struct printjob
*pjob
;
2532 pjob
= print_job_find(sharename
, jobid
);
2535 /* don't allow another process to get this info - it is meaningless */
2536 if (pjob
->pid
!= sys_getpid())
2540 pjob_store(sharename
, jobid
, pjob
);
2543 /****************************************************************************
2544 Print a file - called on closing the file. This spools the job.
2545 If normal close is false then we're tearing down the jobs - treat as an
2547 ****************************************************************************/
2549 bool print_job_end(int snum
, uint32 jobid
, enum file_close_type close_type
)
2551 const char* sharename
= lp_const_servicename(snum
);
2552 struct printjob
*pjob
;
2554 SMB_STRUCT_STAT sbuf
;
2555 struct printif
*current_printif
= get_printer_fns( snum
);
2557 pjob
= print_job_find(sharename
, jobid
);
2562 if (pjob
->spooled
|| pjob
->pid
!= sys_getpid())
2565 if ((close_type
== NORMAL_CLOSE
|| close_type
== SHUTDOWN_CLOSE
) &&
2566 (sys_fstat(pjob
->fd
, &sbuf
) == 0)) {
2567 pjob
->size
= sbuf
.st_size
;
2573 * Not a normal close or we couldn't stat the job file,
2574 * so something has gone wrong. Cleanup.
2578 DEBUG(3,("print_job_end: failed to stat file for jobid %d\n", jobid
));
2582 /* Technically, this is not quite right. If the printer has a separator
2583 * page turned on, the NT spooler prints the separator page even if the
2584 * print job is 0 bytes. 010215 JRR */
2585 if (pjob
->size
== 0 || pjob
->status
== LPQ_DELETING
) {
2586 /* don't bother spooling empty files or something being deleted. */
2587 DEBUG(5,("print_job_end: canceling spool of %s (%s)\n",
2588 pjob
->filename
, pjob
->size
? "deleted" : "zero length" ));
2589 unlink(pjob
->filename
);
2590 pjob_delete(sharename
, jobid
);
2594 pjob
->smbjob
= jobid
;
2596 ret
= (*(current_printif
->job_submit
))(snum
, pjob
);
2601 /* The print job has been successfully handed over to the back-end */
2603 pjob
->spooled
= True
;
2604 pjob
->status
= LPQ_QUEUED
;
2605 pjob_store(sharename
, jobid
, pjob
);
2607 /* make sure the database is up to date */
2608 if (print_cache_expired(lp_const_servicename(snum
), True
))
2609 print_queue_update(snum
, False
);
2615 /* The print job was not successfully started. Cleanup */
2616 /* Still need to add proper error return propagation! 010122:JRR */
2617 unlink(pjob
->filename
);
2618 pjob_delete(sharename
, jobid
);
2622 /****************************************************************************
2623 Get a snapshot of jobs in the system without traversing.
2624 ****************************************************************************/
2626 static bool get_stored_queue_info(struct tdb_print_db
*pdb
, int snum
, int *pcount
, print_queue_struct
**ppqueue
)
2628 TDB_DATA data
, cgdata
;
2629 print_queue_struct
*queue
= NULL
;
2631 uint32 extra_count
= 0;
2632 int total_count
= 0;
2635 int max_reported_jobs
= lp_max_reported_jobs(snum
);
2637 const char* sharename
= lp_servicename(snum
);
2639 /* make sure the database is up to date */
2640 if (print_cache_expired(lp_const_servicename(snum
), True
))
2641 print_queue_update(snum
, False
);
2647 ZERO_STRUCT(cgdata
);
2649 /* Get the stored queue data. */
2650 data
= tdb_fetch(pdb
->tdb
, string_tdb_data("INFO/linear_queue_array"));
2652 if (data
.dptr
&& data
.dsize
>= sizeof(qcount
))
2653 len
+= tdb_unpack(data
.dptr
+ len
, data
.dsize
- len
, "d", &qcount
);
2655 /* Get the changed jobs list. */
2656 cgdata
= tdb_fetch(pdb
->tdb
, string_tdb_data("INFO/jobs_changed"));
2657 if (cgdata
.dptr
!= NULL
&& (cgdata
.dsize
% 4 == 0))
2658 extra_count
= cgdata
.dsize
/4;
2660 DEBUG(5,("get_stored_queue_info: qcount = %u, extra_count = %u\n", (unsigned int)qcount
, (unsigned int)extra_count
));
2662 /* Allocate the queue size. */
2663 if (qcount
== 0 && extra_count
== 0)
2666 if ((queue
= SMB_MALLOC_ARRAY(print_queue_struct
, qcount
+ extra_count
)) == NULL
)
2669 /* Retrieve the linearised queue data. */
2671 for( i
= 0; i
< qcount
; i
++) {
2672 uint32 qjob
, qsize
, qpage_count
, qstatus
, qpriority
, qtime
;
2673 len
+= tdb_unpack(data
.dptr
+ len
, data
.dsize
- len
, "ddddddff",
2682 queue
[i
].job
= qjob
;
2683 queue
[i
].size
= qsize
;
2684 queue
[i
].page_count
= qpage_count
;
2685 queue
[i
].status
= qstatus
;
2686 queue
[i
].priority
= qpriority
;
2687 queue
[i
].time
= qtime
;
2690 total_count
= qcount
;
2692 /* Add in the changed jobids. */
2693 for( i
= 0; i
< extra_count
; i
++) {
2695 struct printjob
*pjob
;
2697 jobid
= IVAL(cgdata
.dptr
, i
*4);
2698 DEBUG(5,("get_stored_queue_info: changed job = %u\n", (unsigned int)jobid
));
2699 pjob
= print_job_find(lp_const_servicename(snum
), jobid
);
2701 DEBUG(5,("get_stored_queue_info: failed to find changed job = %u\n", (unsigned int)jobid
));
2702 remove_from_jobs_changed(sharename
, jobid
);
2706 queue
[total_count
].job
= jobid
;
2707 queue
[total_count
].size
= pjob
->size
;
2708 queue
[total_count
].page_count
= pjob
->page_count
;
2709 queue
[total_count
].status
= pjob
->status
;
2710 queue
[total_count
].priority
= 1;
2711 queue
[total_count
].time
= pjob
->starttime
;
2712 fstrcpy(queue
[total_count
].fs_user
, pjob
->user
);
2713 fstrcpy(queue
[total_count
].fs_file
, pjob
->jobname
);
2717 /* Sort the queue by submission time otherwise they are displayed
2720 qsort(queue
, total_count
, sizeof(print_queue_struct
), QSORT_CAST(printjob_comp
));
2722 DEBUG(5,("get_stored_queue_info: total_count = %u\n", (unsigned int)total_count
));
2724 if (max_reported_jobs
&& total_count
> max_reported_jobs
)
2725 total_count
= max_reported_jobs
;
2728 *pcount
= total_count
;
2734 SAFE_FREE(data
.dptr
);
2735 SAFE_FREE(cgdata
.dptr
);
2739 /****************************************************************************
2740 Get a printer queue listing.
2741 set queue = NULL and status = NULL if you just want to update the cache
2742 ****************************************************************************/
2744 int print_queue_status(int snum
,
2745 print_queue_struct
**ppqueue
,
2746 print_status_struct
*status
)
2750 const char *sharename
;
2751 struct tdb_print_db
*pdb
;
2754 /* make sure the database is up to date */
2756 if (print_cache_expired(lp_const_servicename(snum
), True
))
2757 print_queue_update(snum
, False
);
2759 /* return if we are done */
2760 if ( !ppqueue
|| !status
)
2764 sharename
= lp_const_servicename(snum
);
2765 pdb
= get_print_db_byname(sharename
);
2771 * Fetch the queue status. We must do this first, as there may
2772 * be no jobs in the queue.
2775 ZERO_STRUCTP(status
);
2776 slprintf(keystr
, sizeof(keystr
)-1, "STATUS/%s", sharename
);
2777 key
= string_tdb_data(keystr
);
2779 data
= tdb_fetch(pdb
->tdb
, key
);
2781 if (data
.dsize
== sizeof(*status
)) {
2782 /* this memcpy is ok since the status struct was
2783 not packed before storing it in the tdb */
2784 memcpy(status
, data
.dptr
, sizeof(*status
));
2786 SAFE_FREE(data
.dptr
);
2790 * Now, fetch the print queue information. We first count the number
2791 * of entries, and then only retrieve the queue if necessary.
2794 if (!get_stored_queue_info(pdb
, snum
, &count
, ppqueue
)) {
2795 release_print_db(pdb
);
2799 release_print_db(pdb
);
2803 /****************************************************************************
2805 ****************************************************************************/
2807 WERROR
print_queue_pause(struct auth_serversupplied_info
*server_info
, int snum
)
2810 struct printif
*current_printif
= get_printer_fns( snum
);
2812 if (!print_access_check(server_info
, snum
,
2813 PRINTER_ACCESS_ADMINISTER
)) {
2814 return WERR_ACCESS_DENIED
;
2820 ret
= (*(current_printif
->queue_pause
))(snum
);
2825 return WERR_INVALID_PARAM
;
2828 /* force update the database */
2829 print_cache_flush(lp_const_servicename(snum
));
2831 /* Send a printer notify message */
2833 notify_printer_status(snum
, PRINTER_STATUS_PAUSED
);
2838 /****************************************************************************
2840 ****************************************************************************/
2842 WERROR
print_queue_resume(struct auth_serversupplied_info
*server_info
, int snum
)
2845 struct printif
*current_printif
= get_printer_fns( snum
);
2847 if (!print_access_check(server_info
, snum
,
2848 PRINTER_ACCESS_ADMINISTER
)) {
2849 return WERR_ACCESS_DENIED
;
2854 ret
= (*(current_printif
->queue_resume
))(snum
);
2859 return WERR_INVALID_PARAM
;
2862 /* make sure the database is up to date */
2863 if (print_cache_expired(lp_const_servicename(snum
), True
))
2864 print_queue_update(snum
, True
);
2866 /* Send a printer notify message */
2868 notify_printer_status(snum
, PRINTER_STATUS_OK
);
2873 /****************************************************************************
2874 Purge a queue - implemented by deleting all jobs that we can delete.
2875 ****************************************************************************/
2877 WERROR
print_queue_purge(struct auth_serversupplied_info
*server_info
, int snum
)
2879 print_queue_struct
*queue
;
2880 print_status_struct status
;
2884 /* Force and update so the count is accurate (i.e. not a cached count) */
2885 print_queue_update(snum
, True
);
2887 can_job_admin
= print_access_check(server_info
, snum
,
2888 JOB_ACCESS_ADMINISTER
);
2889 njobs
= print_queue_status(snum
, &queue
, &status
);
2891 if ( can_job_admin
)
2894 for (i
=0;i
<njobs
;i
++) {
2895 bool owner
= is_owner(server_info
, lp_const_servicename(snum
),
2898 if (owner
|| can_job_admin
) {
2899 print_job_delete1(snum
, queue
[i
].job
);
2903 if ( can_job_admin
)
2906 /* update the cache */
2907 print_queue_update( snum
, True
);