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 pid_t background_lpq_updater_pid
= -1;
1392 /****************************************************************************
1393 main thread of the background lpq updater
1394 ****************************************************************************/
1395 void start_background_queue(void)
1397 /* Use local variables for this as we don't
1398 * need to save the parent side of this, just
1399 * ensure it closes when the process exits.
1403 DEBUG(3,("start_background_queue: Starting background LPQ thread\n"));
1405 if (pipe(pause_pipe
) == -1) {
1406 DEBUG(5,("start_background_queue: cannot create pipe. %s\n", strerror(errno
) ));
1410 background_lpq_updater_pid
= sys_fork();
1412 if (background_lpq_updater_pid
== -1) {
1413 DEBUG(5,("start_background_queue: background LPQ thread failed to start. %s\n", strerror(errno
) ));
1417 if(background_lpq_updater_pid
== 0) {
1419 DEBUG(5,("start_background_queue: background LPQ thread started\n"));
1421 close(pause_pipe
[0]);
1424 if (!reinit_after_fork(smbd_messaging_context(),
1425 smbd_event_context(), true)) {
1426 DEBUG(0,("reinit_after_fork() failed\n"));
1427 smb_panic("reinit_after_fork() failed");
1430 smbd_setup_sig_term_handler();
1431 smbd_setup_sig_hup_handler();
1433 claim_connection( NULL
, "smbd lpq backend",
1434 FLAG_MSG_GENERAL
|FLAG_MSG_SMBD
|FLAG_MSG_PRINT_GENERAL
);
1436 if (!locking_init()) {
1440 messaging_register(smbd_messaging_context(), NULL
,
1441 MSG_PRINTER_UPDATE
, print_queue_receive
);
1443 DEBUG(5,("start_background_queue: background LPQ thread waiting for messages\n"));
1445 fd_set r_fds
, w_fds
;
1450 /* Process a signal and timed events now... */
1451 if (run_events(smbd_event_context(), 0, NULL
, NULL
)) {
1455 to
.tv_sec
= SMBD_SELECT_TIMEOUT
;
1459 * Setup the select fd sets.
1466 * Are there any timed events waiting ? If so, ensure we don't
1467 * select for longer than it would take to wait for them.
1474 event_add_to_select_args(smbd_event_context(), &now
,
1475 &r_fds
, &w_fds
, &to
, &maxfd
);
1478 FD_SET(pause_pipe
[1], &r_fds
);
1479 maxfd
= MAX(pause_pipe
[1], maxfd
);
1481 ret
= sys_select(maxfd
, &r_fds
, &w_fds
, NULL
, &to
);
1484 * If pause_pipe[1] is closed it means the parent smbd
1485 * and children exited or aborted. If sys_select()
1486 * failed, then something more sinister is wrong
1489 (ret
== 1 && FD_ISSET(pause_pipe
[1], &r_fds
))) {
1490 exit_server_cleanly(NULL
);
1493 if (run_events(smbd_event_context(), ret
, &r_fds
, &w_fds
)) {
1499 close(pause_pipe
[1]);
1502 /****************************************************************************
1503 update the internal database from the system print queue for a queue
1504 ****************************************************************************/
1506 static void print_queue_update(int snum
, bool force
)
1510 char *lpqcommand
= NULL
;
1511 char *lprmcommand
= NULL
;
1512 uint8
*buffer
= NULL
;
1515 struct tdb_print_db
*pdb
;
1517 struct printif
*current_printif
;
1518 TALLOC_CTX
*ctx
= talloc_tos();
1520 fstrcpy( sharename
, lp_const_servicename(snum
));
1522 /* don't strip out characters like '$' from the printername */
1524 lpqcommand
= talloc_string_sub2(ctx
,
1525 lp_lpqcommand(snum
),
1528 false, false, false);
1532 lpqcommand
= talloc_sub_advanced(ctx
,
1533 lp_servicename(snum
),
1534 current_user_info
.unix_name
,
1536 current_user
.ut
.gid
,
1537 get_current_username(),
1538 current_user_info
.domain
,
1544 lprmcommand
= talloc_string_sub2(ctx
,
1545 lp_lprmcommand(snum
),
1548 false, false, false);
1552 lprmcommand
= talloc_sub_advanced(ctx
,
1553 lp_servicename(snum
),
1554 current_user_info
.unix_name
,
1556 current_user
.ut
.gid
,
1557 get_current_username(),
1558 current_user_info
.domain
,
1565 * Make sure that the background queue process exists.
1566 * Otherwise just do the update ourselves
1569 if ( force
|| background_lpq_updater_pid
== -1 ) {
1570 DEBUG(4,("print_queue_update: updating queue [%s] myself\n", sharename
));
1571 current_printif
= get_printer_fns( snum
);
1572 print_queue_update_with_lock( sharename
, current_printif
, lpqcommand
, lprmcommand
);
1577 type
= lp_printing(snum
);
1579 /* get the length */
1581 len
= tdb_pack( NULL
, 0, "fdPP",
1587 buffer
= SMB_XMALLOC_ARRAY( uint8
, len
);
1589 /* now pack the buffer */
1590 newlen
= tdb_pack( buffer
, len
, "fdPP",
1596 SMB_ASSERT( newlen
== len
);
1598 DEBUG(10,("print_queue_update: Sending message -> printer = %s, "
1599 "type = %d, lpq command = [%s] lprm command = [%s]\n",
1600 sharename
, type
, lpqcommand
, lprmcommand
));
1602 /* here we set a msg pending record for other smbd processes
1603 to throttle the number of duplicate print_queue_update msgs
1606 pdb
= get_print_db_byname(sharename
);
1612 snprintf(key
, sizeof(key
), "MSG_PENDING/%s", sharename
);
1614 if ( !tdb_store_uint32( pdb
->tdb
, key
, time(NULL
) ) ) {
1615 /* log a message but continue on */
1617 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1621 release_print_db( pdb
);
1623 /* finally send the message */
1625 messaging_send_buf(smbd_messaging_context(),
1626 pid_to_procid(background_lpq_updater_pid
),
1627 MSG_PRINTER_UPDATE
, (uint8
*)buffer
, len
);
1629 SAFE_FREE( buffer
);
1634 /****************************************************************************
1635 Create/Update an entry in the print tdb that will allow us to send notify
1636 updates only to interested smbd's.
1637 ****************************************************************************/
1639 bool print_notify_register_pid(int snum
)
1642 struct tdb_print_db
*pdb
= NULL
;
1643 TDB_CONTEXT
*tdb
= NULL
;
1644 const char *printername
;
1645 uint32 mypid
= (uint32
)sys_getpid();
1649 /* if (snum == -1), then the change notify request was
1650 on a print server handle and we need to register on
1655 int num_services
= lp_numservices();
1658 for ( idx
=0; idx
<num_services
; idx
++ ) {
1659 if (lp_snum_ok(idx
) && lp_print_ok(idx
) )
1660 print_notify_register_pid(idx
);
1665 else /* register for a specific printer */
1667 printername
= lp_const_servicename(snum
);
1668 pdb
= get_print_db_byname(printername
);
1674 if (tdb_lock_bystring_with_timeout(tdb
, NOTIFY_PID_LIST_KEY
, 10) == -1) {
1675 DEBUG(0,("print_notify_register_pid: Failed to lock printer %s\n",
1678 release_print_db(pdb
);
1682 data
= get_printer_notify_pid_list( tdb
, printername
, True
);
1684 /* Add ourselves and increase the refcount. */
1686 for (i
= 0; i
< data
.dsize
; i
+= 8) {
1687 if (IVAL(data
.dptr
,i
) == mypid
) {
1688 uint32 new_refcount
= IVAL(data
.dptr
, i
+4) + 1;
1689 SIVAL(data
.dptr
, i
+4, new_refcount
);
1694 if (i
== data
.dsize
) {
1695 /* We weren't in the list. Realloc. */
1696 data
.dptr
= (uint8
*)SMB_REALLOC(data
.dptr
, data
.dsize
+ 8);
1698 DEBUG(0,("print_notify_register_pid: Relloc fail for printer %s\n",
1703 SIVAL(data
.dptr
,data
.dsize
- 8,mypid
);
1704 SIVAL(data
.dptr
,data
.dsize
- 4,1); /* Refcount. */
1707 /* Store back the record. */
1708 if (tdb_store_bystring(tdb
, NOTIFY_PID_LIST_KEY
, data
, TDB_REPLACE
) == -1) {
1709 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1710 list for printer %s\n", printername
));
1718 tdb_unlock_bystring(tdb
, NOTIFY_PID_LIST_KEY
);
1720 release_print_db(pdb
);
1721 SAFE_FREE(data
.dptr
);
1725 /****************************************************************************
1726 Update an entry in the print tdb that will allow us to send notify
1727 updates only to interested smbd's.
1728 ****************************************************************************/
1730 bool print_notify_deregister_pid(int snum
)
1733 struct tdb_print_db
*pdb
= NULL
;
1734 TDB_CONTEXT
*tdb
= NULL
;
1735 const char *printername
;
1736 uint32 mypid
= (uint32
)sys_getpid();
1740 /* if ( snum == -1 ), we are deregister a print server handle
1741 which means to deregister on all print queues */
1745 int num_services
= lp_numservices();
1748 for ( idx
=0; idx
<num_services
; idx
++ ) {
1749 if ( lp_snum_ok(idx
) && lp_print_ok(idx
) )
1750 print_notify_deregister_pid(idx
);
1755 else /* deregister a specific printer */
1757 printername
= lp_const_servicename(snum
);
1758 pdb
= get_print_db_byname(printername
);
1764 if (tdb_lock_bystring_with_timeout(tdb
, NOTIFY_PID_LIST_KEY
, 10) == -1) {
1765 DEBUG(0,("print_notify_register_pid: Failed to lock \
1766 printer %s database\n", printername
));
1768 release_print_db(pdb
);
1772 data
= get_printer_notify_pid_list( tdb
, printername
, True
);
1774 /* Reduce refcount. Remove ourselves if zero. */
1776 for (i
= 0; i
< data
.dsize
; ) {
1777 if (IVAL(data
.dptr
,i
) == mypid
) {
1778 uint32 refcount
= IVAL(data
.dptr
, i
+4);
1782 if (refcount
== 0) {
1783 if (data
.dsize
- i
> 8)
1784 memmove( &data
.dptr
[i
], &data
.dptr
[i
+8], data
.dsize
- i
- 8);
1788 SIVAL(data
.dptr
, i
+4, refcount
);
1794 if (data
.dsize
== 0)
1795 SAFE_FREE(data
.dptr
);
1797 /* Store back the record. */
1798 if (tdb_store_bystring(tdb
, NOTIFY_PID_LIST_KEY
, data
, TDB_REPLACE
) == -1) {
1799 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1800 list for printer %s\n", printername
));
1808 tdb_unlock_bystring(tdb
, NOTIFY_PID_LIST_KEY
);
1810 release_print_db(pdb
);
1811 SAFE_FREE(data
.dptr
);
1815 /****************************************************************************
1816 Check if a jobid is valid. It is valid if it exists in the database.
1817 ****************************************************************************/
1819 bool print_job_exists(const char* sharename
, uint32 jobid
)
1821 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1827 ret
= tdb_exists(pdb
->tdb
, print_key(jobid
, &tmp
));
1828 release_print_db(pdb
);
1832 /****************************************************************************
1833 Give the fd used for a jobid.
1834 ****************************************************************************/
1836 int print_job_fd(const char* sharename
, uint32 jobid
)
1838 struct printjob
*pjob
= print_job_find(sharename
, jobid
);
1841 /* don't allow another process to get this info - it is meaningless */
1842 if (pjob
->pid
!= sys_getpid())
1847 /****************************************************************************
1848 Give the filename used for a jobid.
1849 Only valid for the process doing the spooling and when the job
1850 has not been spooled.
1851 ****************************************************************************/
1853 char *print_job_fname(const char* sharename
, uint32 jobid
)
1855 struct printjob
*pjob
= print_job_find(sharename
, jobid
);
1856 if (!pjob
|| pjob
->spooled
|| pjob
->pid
!= sys_getpid())
1858 return pjob
->filename
;
1862 /****************************************************************************
1863 Give the filename used for a jobid.
1864 Only valid for the process doing the spooling and when the job
1865 has not been spooled.
1866 ****************************************************************************/
1868 NT_DEVICEMODE
*print_job_devmode(const char* sharename
, uint32 jobid
)
1870 struct printjob
*pjob
= print_job_find(sharename
, jobid
);
1875 return pjob
->nt_devmode
;
1878 /****************************************************************************
1879 Set the place in the queue for a job.
1880 ****************************************************************************/
1882 bool print_job_set_place(const char *sharename
, uint32 jobid
, int place
)
1884 DEBUG(2,("print_job_set_place not implemented yet\n"));
1888 /****************************************************************************
1889 Set the name of a job. Only possible for owner.
1890 ****************************************************************************/
1892 bool print_job_set_name(const char *sharename
, uint32 jobid
, char *name
)
1894 struct printjob
*pjob
;
1896 pjob
= print_job_find(sharename
, jobid
);
1897 if (!pjob
|| pjob
->pid
!= sys_getpid())
1900 fstrcpy(pjob
->jobname
, name
);
1901 return pjob_store(sharename
, jobid
, pjob
);
1904 /***************************************************************************
1905 Remove a jobid from the 'jobs changed' list.
1906 ***************************************************************************/
1908 static bool remove_from_jobs_changed(const char* sharename
, uint32 jobid
)
1910 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1912 size_t job_count
, i
;
1914 bool gotlock
= False
;
1922 key
= string_tdb_data("INFO/jobs_changed");
1924 if (tdb_chainlock_with_timeout(pdb
->tdb
, key
, 5) == -1)
1929 data
= tdb_fetch(pdb
->tdb
, key
);
1931 if (data
.dptr
== NULL
|| data
.dsize
== 0 || (data
.dsize
% 4 != 0))
1934 job_count
= data
.dsize
/ 4;
1935 for (i
= 0; i
< job_count
; i
++) {
1938 ch_jobid
= IVAL(data
.dptr
, i
*4);
1939 if (ch_jobid
== jobid
) {
1940 if (i
< job_count
-1 )
1941 memmove(data
.dptr
+ (i
*4), data
.dptr
+ (i
*4) + 4, (job_count
- i
- 1)*4 );
1943 if (tdb_store(pdb
->tdb
, key
, data
, TDB_REPLACE
) == -1)
1953 tdb_chainunlock(pdb
->tdb
, key
);
1954 SAFE_FREE(data
.dptr
);
1955 release_print_db(pdb
);
1957 DEBUG(10,("remove_from_jobs_changed: removed jobid %u\n", (unsigned int)jobid
));
1959 DEBUG(10,("remove_from_jobs_changed: Failed to remove jobid %u\n", (unsigned int)jobid
));
1963 /****************************************************************************
1964 Delete a print job - don't update queue.
1965 ****************************************************************************/
1967 static bool print_job_delete1(int snum
, uint32 jobid
)
1969 const char* sharename
= lp_const_servicename(snum
);
1970 struct printjob
*pjob
= print_job_find(sharename
, jobid
);
1972 struct printif
*current_printif
= get_printer_fns( snum
);
1978 * If already deleting just return.
1981 if (pjob
->status
== LPQ_DELETING
)
1984 /* Hrm - we need to be able to cope with deleting a job before it
1985 has reached the spooler. Just mark it as LPQ_DELETING and
1986 let the print_queue_update() code rmeove the record */
1989 if (pjob
->sysjob
== -1) {
1990 DEBUG(5, ("attempt to delete job %u not seen by lpr\n", (unsigned int)jobid
));
1993 /* Set the tdb entry to be deleting. */
1995 pjob
->status
= LPQ_DELETING
;
1996 pjob_store(sharename
, jobid
, pjob
);
1998 if (pjob
->spooled
&& pjob
->sysjob
!= -1)
2000 result
= (*(current_printif
->job_delete
))(
2002 lp_lprmcommand(snum
),
2005 /* Delete the tdb entry if the delete succeeded or the job hasn't
2009 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
2014 pjob_delete(sharename
, jobid
);
2015 /* Ensure we keep a rough count of the number of total jobs... */
2016 tdb_change_int32_atomic(pdb
->tdb
, "INFO/total_jobs", &njobs
, -1);
2017 release_print_db(pdb
);
2021 remove_from_jobs_changed( sharename
, jobid
);
2023 return (result
== 0);
2026 /****************************************************************************
2027 Return true if the current user owns the print job.
2028 ****************************************************************************/
2030 static bool is_owner(struct auth_serversupplied_info
*server_info
,
2031 const char *servicename
,
2034 struct printjob
*pjob
= print_job_find(servicename
, jobid
);
2036 if (!pjob
|| !server_info
)
2039 return strequal(pjob
->user
, server_info
->sanitized_username
);
2042 /****************************************************************************
2044 ****************************************************************************/
2046 bool print_job_delete(struct auth_serversupplied_info
*server_info
, int snum
,
2047 uint32 jobid
, WERROR
*errcode
)
2049 const char* sharename
= lp_const_servicename( snum
);
2050 struct printjob
*pjob
;
2056 owner
= is_owner(server_info
, lp_const_servicename(snum
), jobid
);
2058 /* Check access against security descriptor or whether the user
2062 !print_access_check(server_info
, snum
, JOB_ACCESS_ADMINISTER
)) {
2063 DEBUG(3, ("delete denied by security descriptor\n"));
2064 *errcode
= WERR_ACCESS_DENIED
;
2066 /* BEGIN_ADMIN_LOG */
2067 sys_adminlog( LOG_ERR
,
2068 "Permission denied-- user not allowed to delete, \
2069 pause, or resume print job. User name: %s. Printer name: %s.",
2070 uidtoname(server_info
->utok
.uid
),
2071 PRINTERNAME(snum
) );
2078 * get the spooled filename of the print job
2079 * if this works, then the file has not been spooled
2080 * to the underlying print system. Just delete the
2081 * spool file & return.
2084 if ( (fname
= print_job_fname( sharename
, jobid
)) != NULL
)
2086 /* remove the spool file */
2087 DEBUG(10,("print_job_delete: Removing spool file [%s]\n", fname
));
2088 if ( unlink( fname
) == -1 ) {
2089 *errcode
= map_werror_from_unix(errno
);
2094 if (!print_job_delete1(snum
, jobid
)) {
2095 *errcode
= WERR_ACCESS_DENIED
;
2099 /* force update the database and say the delete failed if the
2102 print_queue_update(snum
, True
);
2104 pjob
= print_job_find(sharename
, jobid
);
2105 if ( pjob
&& (pjob
->status
!= LPQ_DELETING
) )
2106 *errcode
= WERR_ACCESS_DENIED
;
2108 return (pjob
== NULL
);
2111 /****************************************************************************
2113 ****************************************************************************/
2115 bool print_job_pause(struct auth_serversupplied_info
*server_info
, int snum
,
2116 uint32 jobid
, WERROR
*errcode
)
2118 const char* sharename
= lp_const_servicename(snum
);
2119 struct printjob
*pjob
;
2121 struct printif
*current_printif
= get_printer_fns( snum
);
2123 pjob
= print_job_find(sharename
, jobid
);
2125 if (!pjob
|| !server_info
) {
2126 DEBUG(10, ("print_job_pause: no pjob or user for jobid %u\n",
2127 (unsigned int)jobid
));
2131 if (!pjob
->spooled
|| pjob
->sysjob
== -1) {
2132 DEBUG(10, ("print_job_pause: not spooled or bad sysjob = %d for jobid %u\n",
2133 (int)pjob
->sysjob
, (unsigned int)jobid
));
2137 if (!is_owner(server_info
, lp_const_servicename(snum
), jobid
) &&
2138 !print_access_check(server_info
, snum
, JOB_ACCESS_ADMINISTER
)) {
2139 DEBUG(3, ("pause denied by security descriptor\n"));
2141 /* BEGIN_ADMIN_LOG */
2142 sys_adminlog( LOG_ERR
,
2143 "Permission denied-- user not allowed to delete, \
2144 pause, or resume print job. User name: %s. Printer name: %s.",
2145 uidtoname(server_info
->utok
.uid
),
2146 PRINTERNAME(snum
) );
2149 *errcode
= WERR_ACCESS_DENIED
;
2153 /* need to pause the spooled entry */
2154 ret
= (*(current_printif
->job_pause
))(snum
, pjob
);
2157 *errcode
= WERR_INVALID_PARAM
;
2161 /* force update the database */
2162 print_cache_flush(lp_const_servicename(snum
));
2164 /* Send a printer notify message */
2166 notify_job_status(sharename
, jobid
, JOB_STATUS_PAUSED
);
2168 /* how do we tell if this succeeded? */
2173 /****************************************************************************
2175 ****************************************************************************/
2177 bool print_job_resume(struct auth_serversupplied_info
*server_info
, int snum
,
2178 uint32 jobid
, WERROR
*errcode
)
2180 const char *sharename
= lp_const_servicename(snum
);
2181 struct printjob
*pjob
;
2183 struct printif
*current_printif
= get_printer_fns( snum
);
2185 pjob
= print_job_find(sharename
, jobid
);
2187 if (!pjob
|| !server_info
) {
2188 DEBUG(10, ("print_job_resume: no pjob or user for jobid %u\n",
2189 (unsigned int)jobid
));
2193 if (!pjob
->spooled
|| pjob
->sysjob
== -1) {
2194 DEBUG(10, ("print_job_resume: not spooled or bad sysjob = %d for jobid %u\n",
2195 (int)pjob
->sysjob
, (unsigned int)jobid
));
2199 if (!is_owner(server_info
, lp_const_servicename(snum
), jobid
) &&
2200 !print_access_check(server_info
, snum
, JOB_ACCESS_ADMINISTER
)) {
2201 DEBUG(3, ("resume denied by security descriptor\n"));
2202 *errcode
= WERR_ACCESS_DENIED
;
2204 /* BEGIN_ADMIN_LOG */
2205 sys_adminlog( LOG_ERR
,
2206 "Permission denied-- user not allowed to delete, \
2207 pause, or resume print job. User name: %s. Printer name: %s.",
2208 uidtoname(server_info
->utok
.uid
),
2209 PRINTERNAME(snum
) );
2214 ret
= (*(current_printif
->job_resume
))(snum
, pjob
);
2217 *errcode
= WERR_INVALID_PARAM
;
2221 /* force update the database */
2222 print_cache_flush(lp_const_servicename(snum
));
2224 /* Send a printer notify message */
2226 notify_job_status(sharename
, jobid
, JOB_STATUS_QUEUED
);
2231 /****************************************************************************
2232 Write to a print file.
2233 ****************************************************************************/
2235 ssize_t
print_job_write(int snum
, uint32 jobid
, const char *buf
, SMB_OFF_T pos
, size_t size
)
2237 const char* sharename
= lp_const_servicename(snum
);
2239 struct printjob
*pjob
;
2241 pjob
= print_job_find(sharename
, jobid
);
2245 /* don't allow another process to get this info - it is meaningless */
2246 if (pjob
->pid
!= sys_getpid())
2249 return_code
= write_data_at_offset(pjob
->fd
, buf
, size
, pos
);
2251 if (return_code
>0) {
2253 pjob_store(sharename
, jobid
, pjob
);
2258 /****************************************************************************
2259 Get the queue status - do not update if db is out of date.
2260 ****************************************************************************/
2262 static int get_queue_status(const char* sharename
, print_status_struct
*status
)
2266 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
2270 ZERO_STRUCTP(status
);
2277 fstr_sprintf(keystr
, "STATUS/%s", sharename
);
2278 data
= tdb_fetch(pdb
->tdb
, string_tdb_data(keystr
));
2280 if (data
.dsize
== sizeof(print_status_struct
))
2281 /* this memcpy is ok since the status struct was
2282 not packed before storing it in the tdb */
2283 memcpy(status
, data
.dptr
, sizeof(print_status_struct
));
2284 SAFE_FREE(data
.dptr
);
2287 len
= tdb_fetch_int32(pdb
->tdb
, "INFO/total_jobs");
2288 release_print_db(pdb
);
2289 return (len
== -1 ? 0 : len
);
2292 /****************************************************************************
2293 Determine the number of jobs in a queue.
2294 ****************************************************************************/
2296 int print_queue_length(int snum
, print_status_struct
*pstatus
)
2298 const char* sharename
= lp_const_servicename( snum
);
2299 print_status_struct status
;
2302 ZERO_STRUCT( status
);
2304 /* make sure the database is up to date */
2305 if (print_cache_expired(lp_const_servicename(snum
), True
))
2306 print_queue_update(snum
, False
);
2308 /* also fetch the queue status */
2309 memset(&status
, 0, sizeof(status
));
2310 len
= get_queue_status(sharename
, &status
);
2318 /***************************************************************************
2319 Allocate a jobid. Hold the lock for as short a time as possible.
2320 ***************************************************************************/
2322 static bool allocate_print_jobid(struct tdb_print_db
*pdb
, int snum
, const char *sharename
, uint32
*pjobid
)
2327 *pjobid
= (uint32
)-1;
2329 for (i
= 0; i
< 3; i
++) {
2330 /* Lock the database - only wait 20 seconds. */
2331 if (tdb_lock_bystring_with_timeout(pdb
->tdb
, "INFO/nextjob", 20) == -1) {
2332 DEBUG(0,("allocate_print_jobid: failed to lock printing database %s\n", sharename
));
2336 if (!tdb_fetch_uint32(pdb
->tdb
, "INFO/nextjob", &jobid
)) {
2337 if (tdb_error(pdb
->tdb
) != TDB_ERR_NOEXIST
) {
2338 DEBUG(0, ("allocate_print_jobid: failed to fetch INFO/nextjob for print queue %s\n",
2345 jobid
= NEXT_JOBID(jobid
);
2347 if (tdb_store_int32(pdb
->tdb
, "INFO/nextjob", jobid
)==-1) {
2348 DEBUG(3, ("allocate_print_jobid: failed to store INFO/nextjob.\n"));
2349 tdb_unlock_bystring(pdb
->tdb
, "INFO/nextjob");
2353 /* We've finished with the INFO/nextjob lock. */
2354 tdb_unlock_bystring(pdb
->tdb
, "INFO/nextjob");
2356 if (!print_job_exists(sharename
, jobid
))
2361 DEBUG(0, ("allocate_print_jobid: failed to allocate a print job for queue %s\n",
2363 /* Probably full... */
2368 /* Store a dummy placeholder. */
2374 if (tdb_store(pdb
->tdb
, print_key(jobid
, &tmp
), dum
,
2375 TDB_INSERT
) == -1) {
2376 DEBUG(3, ("allocate_print_jobid: jobid (%d) failed to store placeholder.\n",
2386 /***************************************************************************
2387 Append a jobid to the 'jobs changed' list.
2388 ***************************************************************************/
2390 static bool add_to_jobs_changed(struct tdb_print_db
*pdb
, uint32 jobid
)
2395 SIVAL(&store_jobid
, 0, jobid
);
2396 data
.dptr
= (uint8
*)&store_jobid
;
2399 DEBUG(10,("add_to_jobs_changed: Added jobid %u\n", (unsigned int)jobid
));
2401 return (tdb_append(pdb
->tdb
, string_tdb_data("INFO/jobs_changed"),
2405 /***************************************************************************
2406 Start spooling a job - return the jobid.
2407 ***************************************************************************/
2409 uint32
print_job_start(struct auth_serversupplied_info
*server_info
, int snum
,
2410 const char *jobname
, NT_DEVICEMODE
*nt_devmode
)
2414 struct printjob pjob
;
2415 const char *sharename
= lp_const_servicename(snum
);
2416 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
2424 if (!print_access_check(server_info
, snum
, PRINTER_ACCESS_USE
)) {
2425 DEBUG(3, ("print_job_start: job start denied by security descriptor\n"));
2426 release_print_db(pdb
);
2430 if (!print_time_access_check(lp_servicename(snum
))) {
2431 DEBUG(3, ("print_job_start: job start denied by time check\n"));
2432 release_print_db(pdb
);
2436 path
= lp_pathname(snum
);
2438 /* see if we have sufficient disk space */
2439 if (lp_minprintspace(snum
)) {
2440 uint64_t dspace
, dsize
;
2441 if (sys_fsusage(path
, &dspace
, &dsize
) == 0 &&
2442 dspace
< 2*(uint64_t)lp_minprintspace(snum
)) {
2443 DEBUG(3, ("print_job_start: disk space check failed.\n"));
2444 release_print_db(pdb
);
2450 /* for autoloaded printers, check that the printcap entry still exists */
2451 if (lp_autoloaded(snum
) && !pcap_printername_ok(lp_const_servicename(snum
))) {
2452 DEBUG(3, ("print_job_start: printer name %s check failed.\n", lp_const_servicename(snum
) ));
2453 release_print_db(pdb
);
2458 /* Insure the maximum queue size is not violated */
2459 if ((njobs
= print_queue_length(snum
,NULL
)) > lp_maxprintjobs(snum
)) {
2460 DEBUG(3, ("print_job_start: Queue %s number of jobs (%d) larger than max printjobs per queue (%d).\n",
2461 sharename
, njobs
, lp_maxprintjobs(snum
) ));
2462 release_print_db(pdb
);
2467 DEBUG(10,("print_job_start: Queue %s number of jobs (%d), max printjobs = %d\n",
2468 sharename
, njobs
, lp_maxprintjobs(snum
) ));
2470 if (!allocate_print_jobid(pdb
, snum
, sharename
, &jobid
))
2473 /* create the database entry */
2477 pjob
.pid
= sys_getpid();
2480 pjob
.starttime
= time(NULL
);
2481 pjob
.status
= LPQ_SPOOLING
;
2483 pjob
.spooled
= False
;
2485 pjob
.nt_devmode
= nt_devmode
;
2487 fstrcpy(pjob
.jobname
, jobname
);
2489 fstrcpy(pjob
.user
, lp_printjob_username(snum
));
2490 standard_sub_advanced(sharename
, server_info
->sanitized_username
,
2491 path
, server_info
->utok
.gid
,
2492 server_info
->sanitized_username
,
2493 pdb_get_domain(server_info
->sam_account
),
2494 pjob
.user
, sizeof(pjob
.user
)-1);
2495 /* ensure NULL termination */
2496 pjob
.user
[sizeof(pjob
.user
)-1] = '\0';
2498 fstrcpy(pjob
.queuename
, lp_const_servicename(snum
));
2500 /* we have a job entry - now create the spool file */
2501 slprintf(pjob
.filename
, sizeof(pjob
.filename
)-1, "%s/%s%.8u.XXXXXX",
2502 path
, PRINT_SPOOL_PREFIX
, (unsigned int)jobid
);
2503 pjob
.fd
= smb_mkstemp(pjob
.filename
);
2505 if (pjob
.fd
== -1) {
2506 if (errno
== EACCES
) {
2507 /* Common setup error, force a report. */
2508 DEBUG(0, ("print_job_start: insufficient permissions \
2509 to open spool file %s.\n", pjob
.filename
));
2511 /* Normal case, report at level 3 and above. */
2512 DEBUG(3, ("print_job_start: can't open spool file %s,\n", pjob
.filename
));
2513 DEBUGADD(3, ("errno = %d (%s).\n", errno
, strerror(errno
)));
2518 pjob_store(sharename
, jobid
, &pjob
);
2520 /* Update the 'jobs changed' entry used by print_queue_status. */
2521 add_to_jobs_changed(pdb
, jobid
);
2523 /* Ensure we keep a rough count of the number of total jobs... */
2524 tdb_change_int32_atomic(pdb
->tdb
, "INFO/total_jobs", &njobs
, 1);
2526 release_print_db(pdb
);
2532 pjob_delete(sharename
, jobid
);
2534 release_print_db(pdb
);
2536 DEBUG(3, ("print_job_start: returning fail. Error = %s\n", strerror(errno
) ));
2540 /****************************************************************************
2541 Update the number of pages spooled to jobid
2542 ****************************************************************************/
2544 void print_job_endpage(int snum
, uint32 jobid
)
2546 const char* sharename
= lp_const_servicename(snum
);
2547 struct printjob
*pjob
;
2549 pjob
= print_job_find(sharename
, jobid
);
2552 /* don't allow another process to get this info - it is meaningless */
2553 if (pjob
->pid
!= sys_getpid())
2557 pjob_store(sharename
, jobid
, pjob
);
2560 /****************************************************************************
2561 Print a file - called on closing the file. This spools the job.
2562 If normal close is false then we're tearing down the jobs - treat as an
2564 ****************************************************************************/
2566 bool print_job_end(int snum
, uint32 jobid
, enum file_close_type close_type
)
2568 const char* sharename
= lp_const_servicename(snum
);
2569 struct printjob
*pjob
;
2571 SMB_STRUCT_STAT sbuf
;
2572 struct printif
*current_printif
= get_printer_fns( snum
);
2574 pjob
= print_job_find(sharename
, jobid
);
2579 if (pjob
->spooled
|| pjob
->pid
!= sys_getpid())
2582 if ((close_type
== NORMAL_CLOSE
|| close_type
== SHUTDOWN_CLOSE
) &&
2583 (sys_fstat(pjob
->fd
, &sbuf
) == 0)) {
2584 pjob
->size
= sbuf
.st_size
;
2590 * Not a normal close or we couldn't stat the job file,
2591 * so something has gone wrong. Cleanup.
2595 DEBUG(3,("print_job_end: failed to stat file for jobid %d\n", jobid
));
2599 /* Technically, this is not quite right. If the printer has a separator
2600 * page turned on, the NT spooler prints the separator page even if the
2601 * print job is 0 bytes. 010215 JRR */
2602 if (pjob
->size
== 0 || pjob
->status
== LPQ_DELETING
) {
2603 /* don't bother spooling empty files or something being deleted. */
2604 DEBUG(5,("print_job_end: canceling spool of %s (%s)\n",
2605 pjob
->filename
, pjob
->size
? "deleted" : "zero length" ));
2606 unlink(pjob
->filename
);
2607 pjob_delete(sharename
, jobid
);
2611 pjob
->smbjob
= jobid
;
2613 ret
= (*(current_printif
->job_submit
))(snum
, pjob
);
2618 /* The print job has been successfully handed over to the back-end */
2620 pjob
->spooled
= True
;
2621 pjob
->status
= LPQ_QUEUED
;
2622 pjob_store(sharename
, jobid
, pjob
);
2624 /* make sure the database is up to date */
2625 if (print_cache_expired(lp_const_servicename(snum
), True
))
2626 print_queue_update(snum
, False
);
2632 /* The print job was not successfully started. Cleanup */
2633 /* Still need to add proper error return propagation! 010122:JRR */
2634 unlink(pjob
->filename
);
2635 pjob_delete(sharename
, jobid
);
2639 /****************************************************************************
2640 Get a snapshot of jobs in the system without traversing.
2641 ****************************************************************************/
2643 static bool get_stored_queue_info(struct tdb_print_db
*pdb
, int snum
, int *pcount
, print_queue_struct
**ppqueue
)
2645 TDB_DATA data
, cgdata
;
2646 print_queue_struct
*queue
= NULL
;
2648 uint32 extra_count
= 0;
2649 int total_count
= 0;
2652 int max_reported_jobs
= lp_max_reported_jobs(snum
);
2654 const char* sharename
= lp_servicename(snum
);
2656 /* make sure the database is up to date */
2657 if (print_cache_expired(lp_const_servicename(snum
), True
))
2658 print_queue_update(snum
, False
);
2664 ZERO_STRUCT(cgdata
);
2666 /* Get the stored queue data. */
2667 data
= tdb_fetch(pdb
->tdb
, string_tdb_data("INFO/linear_queue_array"));
2669 if (data
.dptr
&& data
.dsize
>= sizeof(qcount
))
2670 len
+= tdb_unpack(data
.dptr
+ len
, data
.dsize
- len
, "d", &qcount
);
2672 /* Get the changed jobs list. */
2673 cgdata
= tdb_fetch(pdb
->tdb
, string_tdb_data("INFO/jobs_changed"));
2674 if (cgdata
.dptr
!= NULL
&& (cgdata
.dsize
% 4 == 0))
2675 extra_count
= cgdata
.dsize
/4;
2677 DEBUG(5,("get_stored_queue_info: qcount = %u, extra_count = %u\n", (unsigned int)qcount
, (unsigned int)extra_count
));
2679 /* Allocate the queue size. */
2680 if (qcount
== 0 && extra_count
== 0)
2683 if ((queue
= SMB_MALLOC_ARRAY(print_queue_struct
, qcount
+ extra_count
)) == NULL
)
2686 /* Retrieve the linearised queue data. */
2688 for( i
= 0; i
< qcount
; i
++) {
2689 uint32 qjob
, qsize
, qpage_count
, qstatus
, qpriority
, qtime
;
2690 len
+= tdb_unpack(data
.dptr
+ len
, data
.dsize
- len
, "ddddddff",
2699 queue
[i
].job
= qjob
;
2700 queue
[i
].size
= qsize
;
2701 queue
[i
].page_count
= qpage_count
;
2702 queue
[i
].status
= qstatus
;
2703 queue
[i
].priority
= qpriority
;
2704 queue
[i
].time
= qtime
;
2707 total_count
= qcount
;
2709 /* Add in the changed jobids. */
2710 for( i
= 0; i
< extra_count
; i
++) {
2712 struct printjob
*pjob
;
2714 jobid
= IVAL(cgdata
.dptr
, i
*4);
2715 DEBUG(5,("get_stored_queue_info: changed job = %u\n", (unsigned int)jobid
));
2716 pjob
= print_job_find(lp_const_servicename(snum
), jobid
);
2718 DEBUG(5,("get_stored_queue_info: failed to find changed job = %u\n", (unsigned int)jobid
));
2719 remove_from_jobs_changed(sharename
, jobid
);
2723 queue
[total_count
].job
= jobid
;
2724 queue
[total_count
].size
= pjob
->size
;
2725 queue
[total_count
].page_count
= pjob
->page_count
;
2726 queue
[total_count
].status
= pjob
->status
;
2727 queue
[total_count
].priority
= 1;
2728 queue
[total_count
].time
= pjob
->starttime
;
2729 fstrcpy(queue
[total_count
].fs_user
, pjob
->user
);
2730 fstrcpy(queue
[total_count
].fs_file
, pjob
->jobname
);
2734 /* Sort the queue by submission time otherwise they are displayed
2737 qsort(queue
, total_count
, sizeof(print_queue_struct
), QSORT_CAST(printjob_comp
));
2739 DEBUG(5,("get_stored_queue_info: total_count = %u\n", (unsigned int)total_count
));
2741 if (max_reported_jobs
&& total_count
> max_reported_jobs
)
2742 total_count
= max_reported_jobs
;
2745 *pcount
= total_count
;
2751 SAFE_FREE(data
.dptr
);
2752 SAFE_FREE(cgdata
.dptr
);
2756 /****************************************************************************
2757 Get a printer queue listing.
2758 set queue = NULL and status = NULL if you just want to update the cache
2759 ****************************************************************************/
2761 int print_queue_status(int snum
,
2762 print_queue_struct
**ppqueue
,
2763 print_status_struct
*status
)
2767 const char *sharename
;
2768 struct tdb_print_db
*pdb
;
2771 /* make sure the database is up to date */
2773 if (print_cache_expired(lp_const_servicename(snum
), True
))
2774 print_queue_update(snum
, False
);
2776 /* return if we are done */
2777 if ( !ppqueue
|| !status
)
2781 sharename
= lp_const_servicename(snum
);
2782 pdb
= get_print_db_byname(sharename
);
2788 * Fetch the queue status. We must do this first, as there may
2789 * be no jobs in the queue.
2792 ZERO_STRUCTP(status
);
2793 slprintf(keystr
, sizeof(keystr
)-1, "STATUS/%s", sharename
);
2794 key
= string_tdb_data(keystr
);
2796 data
= tdb_fetch(pdb
->tdb
, key
);
2798 if (data
.dsize
== sizeof(*status
)) {
2799 /* this memcpy is ok since the status struct was
2800 not packed before storing it in the tdb */
2801 memcpy(status
, data
.dptr
, sizeof(*status
));
2803 SAFE_FREE(data
.dptr
);
2807 * Now, fetch the print queue information. We first count the number
2808 * of entries, and then only retrieve the queue if necessary.
2811 if (!get_stored_queue_info(pdb
, snum
, &count
, ppqueue
)) {
2812 release_print_db(pdb
);
2816 release_print_db(pdb
);
2820 /****************************************************************************
2822 ****************************************************************************/
2824 bool print_queue_pause(struct auth_serversupplied_info
*server_info
, int snum
,
2828 struct printif
*current_printif
= get_printer_fns( snum
);
2830 if (!print_access_check(server_info
, snum
,
2831 PRINTER_ACCESS_ADMINISTER
)) {
2832 *errcode
= WERR_ACCESS_DENIED
;
2839 ret
= (*(current_printif
->queue_pause
))(snum
);
2844 *errcode
= WERR_INVALID_PARAM
;
2848 /* force update the database */
2849 print_cache_flush(lp_const_servicename(snum
));
2851 /* Send a printer notify message */
2853 notify_printer_status(snum
, PRINTER_STATUS_PAUSED
);
2858 /****************************************************************************
2860 ****************************************************************************/
2862 bool print_queue_resume(struct auth_serversupplied_info
*server_info
, int snum
,
2866 struct printif
*current_printif
= get_printer_fns( snum
);
2868 if (!print_access_check(server_info
, snum
,
2869 PRINTER_ACCESS_ADMINISTER
)) {
2870 *errcode
= WERR_ACCESS_DENIED
;
2876 ret
= (*(current_printif
->queue_resume
))(snum
);
2881 *errcode
= WERR_INVALID_PARAM
;
2885 /* make sure the database is up to date */
2886 if (print_cache_expired(lp_const_servicename(snum
), True
))
2887 print_queue_update(snum
, True
);
2889 /* Send a printer notify message */
2891 notify_printer_status(snum
, PRINTER_STATUS_OK
);
2896 /****************************************************************************
2897 Purge a queue - implemented by deleting all jobs that we can delete.
2898 ****************************************************************************/
2900 bool print_queue_purge(struct auth_serversupplied_info
*server_info
, int snum
,
2903 print_queue_struct
*queue
;
2904 print_status_struct status
;
2908 /* Force and update so the count is accurate (i.e. not a cached count) */
2909 print_queue_update(snum
, True
);
2911 can_job_admin
= print_access_check(server_info
, snum
,
2912 JOB_ACCESS_ADMINISTER
);
2913 njobs
= print_queue_status(snum
, &queue
, &status
);
2915 if ( can_job_admin
)
2918 for (i
=0;i
<njobs
;i
++) {
2919 bool owner
= is_owner(server_info
, lp_const_servicename(snum
),
2922 if (owner
|| can_job_admin
) {
2923 print_job_delete1(snum
, queue
[i
].job
);
2927 if ( can_job_admin
)
2930 /* update the cache */
2931 print_queue_update( snum
, True
);