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 (!reinit_after_fork(smbd_messaging_context(),
1440 smbd_event_context(), true)) {
1441 DEBUG(0,("reinit_after_fork() failed\n"));
1442 smb_panic("reinit_after_fork() failed");
1445 smbd_setup_sig_term_handler();
1446 smbd_setup_sig_hup_handler();
1448 claim_connection( NULL
, "smbd lpq backend",
1449 FLAG_MSG_GENERAL
|FLAG_MSG_SMBD
|FLAG_MSG_PRINT_GENERAL
);
1451 if (!locking_init()) {
1455 messaging_register(smbd_messaging_context(), NULL
,
1456 MSG_PRINTER_UPDATE
, print_queue_receive
);
1458 fde
= tevent_add_fd(smbd_event_context(), smbd_event_context(),
1459 pause_pipe
[1], TEVENT_FD_READ
,
1460 printing_pause_fd_handler
,
1463 DEBUG(0,("tevent_add_fd() failed for pause_pipe\n"));
1464 smb_panic("tevent_add_fd() failed for pause_pipe");
1467 DEBUG(5,("start_background_queue: background LPQ thread waiting for messages\n"));
1468 ret
= tevent_loop_wait(smbd_event_context());
1469 /* should not be reached */
1470 DEBUG(0,("background_queue: tevent_loop_wait() exited with %d - %s\n",
1471 ret
, (ret
== 0) ? "out of events" : strerror(errno
)));
1475 close(pause_pipe
[1]);
1478 /****************************************************************************
1479 update the internal database from the system print queue for a queue
1480 ****************************************************************************/
1482 static void print_queue_update(int snum
, bool force
)
1486 char *lpqcommand
= NULL
;
1487 char *lprmcommand
= NULL
;
1488 uint8
*buffer
= NULL
;
1491 struct tdb_print_db
*pdb
;
1493 struct printif
*current_printif
;
1494 TALLOC_CTX
*ctx
= talloc_tos();
1496 fstrcpy( sharename
, lp_const_servicename(snum
));
1498 /* don't strip out characters like '$' from the printername */
1500 lpqcommand
= talloc_string_sub2(ctx
,
1501 lp_lpqcommand(snum
),
1504 false, false, false);
1508 lpqcommand
= talloc_sub_advanced(ctx
,
1509 lp_servicename(snum
),
1510 current_user_info
.unix_name
,
1512 current_user
.ut
.gid
,
1513 get_current_username(),
1514 current_user_info
.domain
,
1520 lprmcommand
= talloc_string_sub2(ctx
,
1521 lp_lprmcommand(snum
),
1524 false, false, false);
1528 lprmcommand
= talloc_sub_advanced(ctx
,
1529 lp_servicename(snum
),
1530 current_user_info
.unix_name
,
1532 current_user
.ut
.gid
,
1533 get_current_username(),
1534 current_user_info
.domain
,
1541 * Make sure that the background queue process exists.
1542 * Otherwise just do the update ourselves
1545 if ( force
|| background_lpq_updater_pid
== -1 ) {
1546 DEBUG(4,("print_queue_update: updating queue [%s] myself\n", sharename
));
1547 current_printif
= get_printer_fns( snum
);
1548 print_queue_update_with_lock( sharename
, current_printif
, lpqcommand
, lprmcommand
);
1553 type
= lp_printing(snum
);
1555 /* get the length */
1557 len
= tdb_pack( NULL
, 0, "fdPP",
1563 buffer
= SMB_XMALLOC_ARRAY( uint8
, len
);
1565 /* now pack the buffer */
1566 newlen
= tdb_pack( buffer
, len
, "fdPP",
1572 SMB_ASSERT( newlen
== len
);
1574 DEBUG(10,("print_queue_update: Sending message -> printer = %s, "
1575 "type = %d, lpq command = [%s] lprm command = [%s]\n",
1576 sharename
, type
, lpqcommand
, lprmcommand
));
1578 /* here we set a msg pending record for other smbd processes
1579 to throttle the number of duplicate print_queue_update msgs
1582 pdb
= get_print_db_byname(sharename
);
1588 snprintf(key
, sizeof(key
), "MSG_PENDING/%s", sharename
);
1590 if ( !tdb_store_uint32( pdb
->tdb
, key
, time(NULL
) ) ) {
1591 /* log a message but continue on */
1593 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1597 release_print_db( pdb
);
1599 /* finally send the message */
1601 messaging_send_buf(smbd_messaging_context(),
1602 pid_to_procid(background_lpq_updater_pid
),
1603 MSG_PRINTER_UPDATE
, (uint8
*)buffer
, len
);
1605 SAFE_FREE( buffer
);
1610 /****************************************************************************
1611 Create/Update an entry in the print tdb that will allow us to send notify
1612 updates only to interested smbd's.
1613 ****************************************************************************/
1615 bool print_notify_register_pid(int snum
)
1618 struct tdb_print_db
*pdb
= NULL
;
1619 TDB_CONTEXT
*tdb
= NULL
;
1620 const char *printername
;
1621 uint32 mypid
= (uint32
)sys_getpid();
1625 /* if (snum == -1), then the change notify request was
1626 on a print server handle and we need to register on
1631 int num_services
= lp_numservices();
1634 for ( idx
=0; idx
<num_services
; idx
++ ) {
1635 if (lp_snum_ok(idx
) && lp_print_ok(idx
) )
1636 print_notify_register_pid(idx
);
1641 else /* register for a specific printer */
1643 printername
= lp_const_servicename(snum
);
1644 pdb
= get_print_db_byname(printername
);
1650 if (tdb_lock_bystring_with_timeout(tdb
, NOTIFY_PID_LIST_KEY
, 10) == -1) {
1651 DEBUG(0,("print_notify_register_pid: Failed to lock printer %s\n",
1654 release_print_db(pdb
);
1658 data
= get_printer_notify_pid_list( tdb
, printername
, True
);
1660 /* Add ourselves and increase the refcount. */
1662 for (i
= 0; i
< data
.dsize
; i
+= 8) {
1663 if (IVAL(data
.dptr
,i
) == mypid
) {
1664 uint32 new_refcount
= IVAL(data
.dptr
, i
+4) + 1;
1665 SIVAL(data
.dptr
, i
+4, new_refcount
);
1670 if (i
== data
.dsize
) {
1671 /* We weren't in the list. Realloc. */
1672 data
.dptr
= (uint8
*)SMB_REALLOC(data
.dptr
, data
.dsize
+ 8);
1674 DEBUG(0,("print_notify_register_pid: Relloc fail for printer %s\n",
1679 SIVAL(data
.dptr
,data
.dsize
- 8,mypid
);
1680 SIVAL(data
.dptr
,data
.dsize
- 4,1); /* Refcount. */
1683 /* Store back the record. */
1684 if (tdb_store_bystring(tdb
, NOTIFY_PID_LIST_KEY
, data
, TDB_REPLACE
) == -1) {
1685 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1686 list for printer %s\n", printername
));
1694 tdb_unlock_bystring(tdb
, NOTIFY_PID_LIST_KEY
);
1696 release_print_db(pdb
);
1697 SAFE_FREE(data
.dptr
);
1701 /****************************************************************************
1702 Update an entry in the print tdb that will allow us to send notify
1703 updates only to interested smbd's.
1704 ****************************************************************************/
1706 bool print_notify_deregister_pid(int snum
)
1709 struct tdb_print_db
*pdb
= NULL
;
1710 TDB_CONTEXT
*tdb
= NULL
;
1711 const char *printername
;
1712 uint32 mypid
= (uint32
)sys_getpid();
1716 /* if ( snum == -1 ), we are deregister a print server handle
1717 which means to deregister on all print queues */
1721 int num_services
= lp_numservices();
1724 for ( idx
=0; idx
<num_services
; idx
++ ) {
1725 if ( lp_snum_ok(idx
) && lp_print_ok(idx
) )
1726 print_notify_deregister_pid(idx
);
1731 else /* deregister a specific printer */
1733 printername
= lp_const_servicename(snum
);
1734 pdb
= get_print_db_byname(printername
);
1740 if (tdb_lock_bystring_with_timeout(tdb
, NOTIFY_PID_LIST_KEY
, 10) == -1) {
1741 DEBUG(0,("print_notify_register_pid: Failed to lock \
1742 printer %s database\n", printername
));
1744 release_print_db(pdb
);
1748 data
= get_printer_notify_pid_list( tdb
, printername
, True
);
1750 /* Reduce refcount. Remove ourselves if zero. */
1752 for (i
= 0; i
< data
.dsize
; ) {
1753 if (IVAL(data
.dptr
,i
) == mypid
) {
1754 uint32 refcount
= IVAL(data
.dptr
, i
+4);
1758 if (refcount
== 0) {
1759 if (data
.dsize
- i
> 8)
1760 memmove( &data
.dptr
[i
], &data
.dptr
[i
+8], data
.dsize
- i
- 8);
1764 SIVAL(data
.dptr
, i
+4, refcount
);
1770 if (data
.dsize
== 0)
1771 SAFE_FREE(data
.dptr
);
1773 /* Store back the record. */
1774 if (tdb_store_bystring(tdb
, NOTIFY_PID_LIST_KEY
, data
, TDB_REPLACE
) == -1) {
1775 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1776 list for printer %s\n", printername
));
1784 tdb_unlock_bystring(tdb
, NOTIFY_PID_LIST_KEY
);
1786 release_print_db(pdb
);
1787 SAFE_FREE(data
.dptr
);
1791 /****************************************************************************
1792 Check if a jobid is valid. It is valid if it exists in the database.
1793 ****************************************************************************/
1795 bool print_job_exists(const char* sharename
, uint32 jobid
)
1797 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1803 ret
= tdb_exists(pdb
->tdb
, print_key(jobid
, &tmp
));
1804 release_print_db(pdb
);
1808 /****************************************************************************
1809 Give the fd used for a jobid.
1810 ****************************************************************************/
1812 int print_job_fd(const char* sharename
, uint32 jobid
)
1814 struct printjob
*pjob
= print_job_find(sharename
, jobid
);
1817 /* don't allow another process to get this info - it is meaningless */
1818 if (pjob
->pid
!= sys_getpid())
1823 /****************************************************************************
1824 Give the filename used for a jobid.
1825 Only valid for the process doing the spooling and when the job
1826 has not been spooled.
1827 ****************************************************************************/
1829 char *print_job_fname(const char* sharename
, uint32 jobid
)
1831 struct printjob
*pjob
= print_job_find(sharename
, jobid
);
1832 if (!pjob
|| pjob
->spooled
|| pjob
->pid
!= sys_getpid())
1834 return pjob
->filename
;
1838 /****************************************************************************
1839 Give the filename used for a jobid.
1840 Only valid for the process doing the spooling and when the job
1841 has not been spooled.
1842 ****************************************************************************/
1844 NT_DEVICEMODE
*print_job_devmode(const char* sharename
, uint32 jobid
)
1846 struct printjob
*pjob
= print_job_find(sharename
, jobid
);
1851 return pjob
->nt_devmode
;
1854 /****************************************************************************
1855 Set the place in the queue for a job.
1856 ****************************************************************************/
1858 bool print_job_set_place(const char *sharename
, uint32 jobid
, int place
)
1860 DEBUG(2,("print_job_set_place not implemented yet\n"));
1864 /****************************************************************************
1865 Set the name of a job. Only possible for owner.
1866 ****************************************************************************/
1868 bool print_job_set_name(const char *sharename
, uint32 jobid
, char *name
)
1870 struct printjob
*pjob
;
1872 pjob
= print_job_find(sharename
, jobid
);
1873 if (!pjob
|| pjob
->pid
!= sys_getpid())
1876 fstrcpy(pjob
->jobname
, name
);
1877 return pjob_store(sharename
, jobid
, pjob
);
1880 /***************************************************************************
1881 Remove a jobid from the 'jobs changed' list.
1882 ***************************************************************************/
1884 static bool remove_from_jobs_changed(const char* sharename
, uint32 jobid
)
1886 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1888 size_t job_count
, i
;
1890 bool gotlock
= False
;
1898 key
= string_tdb_data("INFO/jobs_changed");
1900 if (tdb_chainlock_with_timeout(pdb
->tdb
, key
, 5) == -1)
1905 data
= tdb_fetch(pdb
->tdb
, key
);
1907 if (data
.dptr
== NULL
|| data
.dsize
== 0 || (data
.dsize
% 4 != 0))
1910 job_count
= data
.dsize
/ 4;
1911 for (i
= 0; i
< job_count
; i
++) {
1914 ch_jobid
= IVAL(data
.dptr
, i
*4);
1915 if (ch_jobid
== jobid
) {
1916 if (i
< job_count
-1 )
1917 memmove(data
.dptr
+ (i
*4), data
.dptr
+ (i
*4) + 4, (job_count
- i
- 1)*4 );
1919 if (tdb_store(pdb
->tdb
, key
, data
, TDB_REPLACE
) == -1)
1929 tdb_chainunlock(pdb
->tdb
, key
);
1930 SAFE_FREE(data
.dptr
);
1931 release_print_db(pdb
);
1933 DEBUG(10,("remove_from_jobs_changed: removed jobid %u\n", (unsigned int)jobid
));
1935 DEBUG(10,("remove_from_jobs_changed: Failed to remove jobid %u\n", (unsigned int)jobid
));
1939 /****************************************************************************
1940 Delete a print job - don't update queue.
1941 ****************************************************************************/
1943 static bool print_job_delete1(int snum
, uint32 jobid
)
1945 const char* sharename
= lp_const_servicename(snum
);
1946 struct printjob
*pjob
= print_job_find(sharename
, jobid
);
1948 struct printif
*current_printif
= get_printer_fns( snum
);
1954 * If already deleting just return.
1957 if (pjob
->status
== LPQ_DELETING
)
1960 /* Hrm - we need to be able to cope with deleting a job before it
1961 has reached the spooler. Just mark it as LPQ_DELETING and
1962 let the print_queue_update() code rmeove the record */
1965 if (pjob
->sysjob
== -1) {
1966 DEBUG(5, ("attempt to delete job %u not seen by lpr\n", (unsigned int)jobid
));
1969 /* Set the tdb entry to be deleting. */
1971 pjob
->status
= LPQ_DELETING
;
1972 pjob_store(sharename
, jobid
, pjob
);
1974 if (pjob
->spooled
&& pjob
->sysjob
!= -1)
1976 result
= (*(current_printif
->job_delete
))(
1978 lp_lprmcommand(snum
),
1981 /* Delete the tdb entry if the delete succeeded or the job hasn't
1985 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1990 pjob_delete(sharename
, jobid
);
1991 /* Ensure we keep a rough count of the number of total jobs... */
1992 tdb_change_int32_atomic(pdb
->tdb
, "INFO/total_jobs", &njobs
, -1);
1993 release_print_db(pdb
);
1997 remove_from_jobs_changed( sharename
, jobid
);
1999 return (result
== 0);
2002 /****************************************************************************
2003 Return true if the current user owns the print job.
2004 ****************************************************************************/
2006 static bool is_owner(struct auth_serversupplied_info
*server_info
,
2007 const char *servicename
,
2010 struct printjob
*pjob
= print_job_find(servicename
, jobid
);
2012 if (!pjob
|| !server_info
)
2015 return strequal(pjob
->user
, server_info
->sanitized_username
);
2018 /****************************************************************************
2020 ****************************************************************************/
2022 bool print_job_delete(struct auth_serversupplied_info
*server_info
, int snum
,
2023 uint32 jobid
, WERROR
*errcode
)
2025 const char* sharename
= lp_const_servicename( snum
);
2026 struct printjob
*pjob
;
2032 owner
= is_owner(server_info
, lp_const_servicename(snum
), jobid
);
2034 /* Check access against security descriptor or whether the user
2038 !print_access_check(server_info
, snum
, JOB_ACCESS_ADMINISTER
)) {
2039 DEBUG(3, ("delete denied by security descriptor\n"));
2040 *errcode
= WERR_ACCESS_DENIED
;
2042 /* BEGIN_ADMIN_LOG */
2043 sys_adminlog( LOG_ERR
,
2044 "Permission denied-- user not allowed to delete, \
2045 pause, or resume print job. User name: %s. Printer name: %s.",
2046 uidtoname(server_info
->utok
.uid
),
2047 PRINTERNAME(snum
) );
2054 * get the spooled filename of the print job
2055 * if this works, then the file has not been spooled
2056 * to the underlying print system. Just delete the
2057 * spool file & return.
2060 if ( (fname
= print_job_fname( sharename
, jobid
)) != NULL
)
2062 /* remove the spool file */
2063 DEBUG(10,("print_job_delete: Removing spool file [%s]\n", fname
));
2064 if ( unlink( fname
) == -1 ) {
2065 *errcode
= map_werror_from_unix(errno
);
2070 if (!print_job_delete1(snum
, jobid
)) {
2071 *errcode
= WERR_ACCESS_DENIED
;
2075 /* force update the database and say the delete failed if the
2078 print_queue_update(snum
, True
);
2080 pjob
= print_job_find(sharename
, jobid
);
2081 if ( pjob
&& (pjob
->status
!= LPQ_DELETING
) )
2082 *errcode
= WERR_ACCESS_DENIED
;
2084 return (pjob
== NULL
);
2087 /****************************************************************************
2089 ****************************************************************************/
2091 bool print_job_pause(struct auth_serversupplied_info
*server_info
, int snum
,
2092 uint32 jobid
, WERROR
*errcode
)
2094 const char* sharename
= lp_const_servicename(snum
);
2095 struct printjob
*pjob
;
2097 struct printif
*current_printif
= get_printer_fns( snum
);
2099 pjob
= print_job_find(sharename
, jobid
);
2101 if (!pjob
|| !server_info
) {
2102 DEBUG(10, ("print_job_pause: no pjob or user for jobid %u\n",
2103 (unsigned int)jobid
));
2107 if (!pjob
->spooled
|| pjob
->sysjob
== -1) {
2108 DEBUG(10, ("print_job_pause: not spooled or bad sysjob = %d for jobid %u\n",
2109 (int)pjob
->sysjob
, (unsigned int)jobid
));
2113 if (!is_owner(server_info
, lp_const_servicename(snum
), jobid
) &&
2114 !print_access_check(server_info
, snum
, JOB_ACCESS_ADMINISTER
)) {
2115 DEBUG(3, ("pause denied by security descriptor\n"));
2117 /* BEGIN_ADMIN_LOG */
2118 sys_adminlog( LOG_ERR
,
2119 "Permission denied-- user not allowed to delete, \
2120 pause, or resume print job. User name: %s. Printer name: %s.",
2121 uidtoname(server_info
->utok
.uid
),
2122 PRINTERNAME(snum
) );
2125 *errcode
= WERR_ACCESS_DENIED
;
2129 /* need to pause the spooled entry */
2130 ret
= (*(current_printif
->job_pause
))(snum
, pjob
);
2133 *errcode
= WERR_INVALID_PARAM
;
2137 /* force update the database */
2138 print_cache_flush(lp_const_servicename(snum
));
2140 /* Send a printer notify message */
2142 notify_job_status(sharename
, jobid
, JOB_STATUS_PAUSED
);
2144 /* how do we tell if this succeeded? */
2149 /****************************************************************************
2151 ****************************************************************************/
2153 bool print_job_resume(struct auth_serversupplied_info
*server_info
, int snum
,
2154 uint32 jobid
, WERROR
*errcode
)
2156 const char *sharename
= lp_const_servicename(snum
);
2157 struct printjob
*pjob
;
2159 struct printif
*current_printif
= get_printer_fns( snum
);
2161 pjob
= print_job_find(sharename
, jobid
);
2163 if (!pjob
|| !server_info
) {
2164 DEBUG(10, ("print_job_resume: no pjob or user for jobid %u\n",
2165 (unsigned int)jobid
));
2169 if (!pjob
->spooled
|| pjob
->sysjob
== -1) {
2170 DEBUG(10, ("print_job_resume: not spooled or bad sysjob = %d for jobid %u\n",
2171 (int)pjob
->sysjob
, (unsigned int)jobid
));
2175 if (!is_owner(server_info
, lp_const_servicename(snum
), jobid
) &&
2176 !print_access_check(server_info
, snum
, JOB_ACCESS_ADMINISTER
)) {
2177 DEBUG(3, ("resume denied by security descriptor\n"));
2178 *errcode
= WERR_ACCESS_DENIED
;
2180 /* BEGIN_ADMIN_LOG */
2181 sys_adminlog( LOG_ERR
,
2182 "Permission denied-- user not allowed to delete, \
2183 pause, or resume print job. User name: %s. Printer name: %s.",
2184 uidtoname(server_info
->utok
.uid
),
2185 PRINTERNAME(snum
) );
2190 ret
= (*(current_printif
->job_resume
))(snum
, pjob
);
2193 *errcode
= WERR_INVALID_PARAM
;
2197 /* force update the database */
2198 print_cache_flush(lp_const_servicename(snum
));
2200 /* Send a printer notify message */
2202 notify_job_status(sharename
, jobid
, JOB_STATUS_QUEUED
);
2207 /****************************************************************************
2208 Write to a print file.
2209 ****************************************************************************/
2211 ssize_t
print_job_write(int snum
, uint32 jobid
, const char *buf
, SMB_OFF_T pos
, size_t size
)
2213 const char* sharename
= lp_const_servicename(snum
);
2215 struct printjob
*pjob
;
2217 pjob
= print_job_find(sharename
, jobid
);
2221 /* don't allow another process to get this info - it is meaningless */
2222 if (pjob
->pid
!= sys_getpid())
2225 return_code
= write_data_at_offset(pjob
->fd
, buf
, size
, pos
);
2227 if (return_code
>0) {
2229 pjob_store(sharename
, jobid
, pjob
);
2234 /****************************************************************************
2235 Get the queue status - do not update if db is out of date.
2236 ****************************************************************************/
2238 static int get_queue_status(const char* sharename
, print_status_struct
*status
)
2242 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
2246 ZERO_STRUCTP(status
);
2253 fstr_sprintf(keystr
, "STATUS/%s", sharename
);
2254 data
= tdb_fetch(pdb
->tdb
, string_tdb_data(keystr
));
2256 if (data
.dsize
== sizeof(print_status_struct
))
2257 /* this memcpy is ok since the status struct was
2258 not packed before storing it in the tdb */
2259 memcpy(status
, data
.dptr
, sizeof(print_status_struct
));
2260 SAFE_FREE(data
.dptr
);
2263 len
= tdb_fetch_int32(pdb
->tdb
, "INFO/total_jobs");
2264 release_print_db(pdb
);
2265 return (len
== -1 ? 0 : len
);
2268 /****************************************************************************
2269 Determine the number of jobs in a queue.
2270 ****************************************************************************/
2272 int print_queue_length(int snum
, print_status_struct
*pstatus
)
2274 const char* sharename
= lp_const_servicename( snum
);
2275 print_status_struct status
;
2278 ZERO_STRUCT( status
);
2280 /* make sure the database is up to date */
2281 if (print_cache_expired(lp_const_servicename(snum
), True
))
2282 print_queue_update(snum
, False
);
2284 /* also fetch the queue status */
2285 memset(&status
, 0, sizeof(status
));
2286 len
= get_queue_status(sharename
, &status
);
2294 /***************************************************************************
2295 Allocate a jobid. Hold the lock for as short a time as possible.
2296 ***************************************************************************/
2298 static bool allocate_print_jobid(struct tdb_print_db
*pdb
, int snum
, const char *sharename
, uint32
*pjobid
)
2303 *pjobid
= (uint32
)-1;
2305 for (i
= 0; i
< 3; i
++) {
2306 /* Lock the database - only wait 20 seconds. */
2307 if (tdb_lock_bystring_with_timeout(pdb
->tdb
, "INFO/nextjob", 20) == -1) {
2308 DEBUG(0,("allocate_print_jobid: failed to lock printing database %s\n", sharename
));
2312 if (!tdb_fetch_uint32(pdb
->tdb
, "INFO/nextjob", &jobid
)) {
2313 if (tdb_error(pdb
->tdb
) != TDB_ERR_NOEXIST
) {
2314 DEBUG(0, ("allocate_print_jobid: failed to fetch INFO/nextjob for print queue %s\n",
2321 jobid
= NEXT_JOBID(jobid
);
2323 if (tdb_store_int32(pdb
->tdb
, "INFO/nextjob", jobid
)==-1) {
2324 DEBUG(3, ("allocate_print_jobid: failed to store INFO/nextjob.\n"));
2325 tdb_unlock_bystring(pdb
->tdb
, "INFO/nextjob");
2329 /* We've finished with the INFO/nextjob lock. */
2330 tdb_unlock_bystring(pdb
->tdb
, "INFO/nextjob");
2332 if (!print_job_exists(sharename
, jobid
))
2337 DEBUG(0, ("allocate_print_jobid: failed to allocate a print job for queue %s\n",
2339 /* Probably full... */
2344 /* Store a dummy placeholder. */
2350 if (tdb_store(pdb
->tdb
, print_key(jobid
, &tmp
), dum
,
2351 TDB_INSERT
) == -1) {
2352 DEBUG(3, ("allocate_print_jobid: jobid (%d) failed to store placeholder.\n",
2362 /***************************************************************************
2363 Append a jobid to the 'jobs changed' list.
2364 ***************************************************************************/
2366 static bool add_to_jobs_changed(struct tdb_print_db
*pdb
, uint32 jobid
)
2371 SIVAL(&store_jobid
, 0, jobid
);
2372 data
.dptr
= (uint8
*)&store_jobid
;
2375 DEBUG(10,("add_to_jobs_changed: Added jobid %u\n", (unsigned int)jobid
));
2377 return (tdb_append(pdb
->tdb
, string_tdb_data("INFO/jobs_changed"),
2381 /***************************************************************************
2382 Start spooling a job - return the jobid.
2383 ***************************************************************************/
2385 uint32
print_job_start(struct auth_serversupplied_info
*server_info
, int snum
,
2386 const char *jobname
, NT_DEVICEMODE
*nt_devmode
)
2390 struct printjob pjob
;
2391 const char *sharename
= lp_const_servicename(snum
);
2392 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
2400 if (!print_access_check(server_info
, snum
, PRINTER_ACCESS_USE
)) {
2401 DEBUG(3, ("print_job_start: job start denied by security descriptor\n"));
2402 release_print_db(pdb
);
2406 if (!print_time_access_check(lp_servicename(snum
))) {
2407 DEBUG(3, ("print_job_start: job start denied by time check\n"));
2408 release_print_db(pdb
);
2412 path
= lp_pathname(snum
);
2414 /* see if we have sufficient disk space */
2415 if (lp_minprintspace(snum
)) {
2416 uint64_t dspace
, dsize
;
2417 if (sys_fsusage(path
, &dspace
, &dsize
) == 0 &&
2418 dspace
< 2*(uint64_t)lp_minprintspace(snum
)) {
2419 DEBUG(3, ("print_job_start: disk space check failed.\n"));
2420 release_print_db(pdb
);
2426 /* for autoloaded printers, check that the printcap entry still exists */
2427 if (lp_autoloaded(snum
) && !pcap_printername_ok(lp_const_servicename(snum
))) {
2428 DEBUG(3, ("print_job_start: printer name %s check failed.\n", lp_const_servicename(snum
) ));
2429 release_print_db(pdb
);
2434 /* Insure the maximum queue size is not violated */
2435 if ((njobs
= print_queue_length(snum
,NULL
)) > lp_maxprintjobs(snum
)) {
2436 DEBUG(3, ("print_job_start: Queue %s number of jobs (%d) larger than max printjobs per queue (%d).\n",
2437 sharename
, njobs
, lp_maxprintjobs(snum
) ));
2438 release_print_db(pdb
);
2443 DEBUG(10,("print_job_start: Queue %s number of jobs (%d), max printjobs = %d\n",
2444 sharename
, njobs
, lp_maxprintjobs(snum
) ));
2446 if (!allocate_print_jobid(pdb
, snum
, sharename
, &jobid
))
2449 /* create the database entry */
2453 pjob
.pid
= sys_getpid();
2456 pjob
.starttime
= time(NULL
);
2457 pjob
.status
= LPQ_SPOOLING
;
2459 pjob
.spooled
= False
;
2461 pjob
.nt_devmode
= nt_devmode
;
2463 fstrcpy(pjob
.jobname
, jobname
);
2465 fstrcpy(pjob
.user
, lp_printjob_username(snum
));
2466 standard_sub_advanced(sharename
, server_info
->sanitized_username
,
2467 path
, server_info
->utok
.gid
,
2468 server_info
->sanitized_username
,
2469 pdb_get_domain(server_info
->sam_account
),
2470 pjob
.user
, sizeof(pjob
.user
)-1);
2471 /* ensure NULL termination */
2472 pjob
.user
[sizeof(pjob
.user
)-1] = '\0';
2474 fstrcpy(pjob
.queuename
, lp_const_servicename(snum
));
2476 /* we have a job entry - now create the spool file */
2477 slprintf(pjob
.filename
, sizeof(pjob
.filename
)-1, "%s/%s%.8u.XXXXXX",
2478 path
, PRINT_SPOOL_PREFIX
, (unsigned int)jobid
);
2479 pjob
.fd
= smb_mkstemp(pjob
.filename
);
2481 if (pjob
.fd
== -1) {
2482 if (errno
== EACCES
) {
2483 /* Common setup error, force a report. */
2484 DEBUG(0, ("print_job_start: insufficient permissions \
2485 to open spool file %s.\n", pjob
.filename
));
2487 /* Normal case, report at level 3 and above. */
2488 DEBUG(3, ("print_job_start: can't open spool file %s,\n", pjob
.filename
));
2489 DEBUGADD(3, ("errno = %d (%s).\n", errno
, strerror(errno
)));
2494 pjob_store(sharename
, jobid
, &pjob
);
2496 /* Update the 'jobs changed' entry used by print_queue_status. */
2497 add_to_jobs_changed(pdb
, jobid
);
2499 /* Ensure we keep a rough count of the number of total jobs... */
2500 tdb_change_int32_atomic(pdb
->tdb
, "INFO/total_jobs", &njobs
, 1);
2502 release_print_db(pdb
);
2508 pjob_delete(sharename
, jobid
);
2510 release_print_db(pdb
);
2512 DEBUG(3, ("print_job_start: returning fail. Error = %s\n", strerror(errno
) ));
2516 /****************************************************************************
2517 Update the number of pages spooled to jobid
2518 ****************************************************************************/
2520 void print_job_endpage(int snum
, uint32 jobid
)
2522 const char* sharename
= lp_const_servicename(snum
);
2523 struct printjob
*pjob
;
2525 pjob
= print_job_find(sharename
, jobid
);
2528 /* don't allow another process to get this info - it is meaningless */
2529 if (pjob
->pid
!= sys_getpid())
2533 pjob_store(sharename
, jobid
, pjob
);
2536 /****************************************************************************
2537 Print a file - called on closing the file. This spools the job.
2538 If normal close is false then we're tearing down the jobs - treat as an
2540 ****************************************************************************/
2542 bool print_job_end(int snum
, uint32 jobid
, enum file_close_type close_type
)
2544 const char* sharename
= lp_const_servicename(snum
);
2545 struct printjob
*pjob
;
2547 SMB_STRUCT_STAT sbuf
;
2548 struct printif
*current_printif
= get_printer_fns( snum
);
2550 pjob
= print_job_find(sharename
, jobid
);
2555 if (pjob
->spooled
|| pjob
->pid
!= sys_getpid())
2558 if ((close_type
== NORMAL_CLOSE
|| close_type
== SHUTDOWN_CLOSE
) &&
2559 (sys_fstat(pjob
->fd
, &sbuf
) == 0)) {
2560 pjob
->size
= sbuf
.st_size
;
2566 * Not a normal close or we couldn't stat the job file,
2567 * so something has gone wrong. Cleanup.
2571 DEBUG(3,("print_job_end: failed to stat file for jobid %d\n", jobid
));
2575 /* Technically, this is not quite right. If the printer has a separator
2576 * page turned on, the NT spooler prints the separator page even if the
2577 * print job is 0 bytes. 010215 JRR */
2578 if (pjob
->size
== 0 || pjob
->status
== LPQ_DELETING
) {
2579 /* don't bother spooling empty files or something being deleted. */
2580 DEBUG(5,("print_job_end: canceling spool of %s (%s)\n",
2581 pjob
->filename
, pjob
->size
? "deleted" : "zero length" ));
2582 unlink(pjob
->filename
);
2583 pjob_delete(sharename
, jobid
);
2587 pjob
->smbjob
= jobid
;
2589 ret
= (*(current_printif
->job_submit
))(snum
, pjob
);
2594 /* The print job has been successfully handed over to the back-end */
2596 pjob
->spooled
= True
;
2597 pjob
->status
= LPQ_QUEUED
;
2598 pjob_store(sharename
, jobid
, pjob
);
2600 /* make sure the database is up to date */
2601 if (print_cache_expired(lp_const_servicename(snum
), True
))
2602 print_queue_update(snum
, False
);
2608 /* The print job was not successfully started. Cleanup */
2609 /* Still need to add proper error return propagation! 010122:JRR */
2610 unlink(pjob
->filename
);
2611 pjob_delete(sharename
, jobid
);
2615 /****************************************************************************
2616 Get a snapshot of jobs in the system without traversing.
2617 ****************************************************************************/
2619 static bool get_stored_queue_info(struct tdb_print_db
*pdb
, int snum
, int *pcount
, print_queue_struct
**ppqueue
)
2621 TDB_DATA data
, cgdata
;
2622 print_queue_struct
*queue
= NULL
;
2624 uint32 extra_count
= 0;
2625 int total_count
= 0;
2628 int max_reported_jobs
= lp_max_reported_jobs(snum
);
2630 const char* sharename
= lp_servicename(snum
);
2632 /* make sure the database is up to date */
2633 if (print_cache_expired(lp_const_servicename(snum
), True
))
2634 print_queue_update(snum
, False
);
2640 ZERO_STRUCT(cgdata
);
2642 /* Get the stored queue data. */
2643 data
= tdb_fetch(pdb
->tdb
, string_tdb_data("INFO/linear_queue_array"));
2645 if (data
.dptr
&& data
.dsize
>= sizeof(qcount
))
2646 len
+= tdb_unpack(data
.dptr
+ len
, data
.dsize
- len
, "d", &qcount
);
2648 /* Get the changed jobs list. */
2649 cgdata
= tdb_fetch(pdb
->tdb
, string_tdb_data("INFO/jobs_changed"));
2650 if (cgdata
.dptr
!= NULL
&& (cgdata
.dsize
% 4 == 0))
2651 extra_count
= cgdata
.dsize
/4;
2653 DEBUG(5,("get_stored_queue_info: qcount = %u, extra_count = %u\n", (unsigned int)qcount
, (unsigned int)extra_count
));
2655 /* Allocate the queue size. */
2656 if (qcount
== 0 && extra_count
== 0)
2659 if ((queue
= SMB_MALLOC_ARRAY(print_queue_struct
, qcount
+ extra_count
)) == NULL
)
2662 /* Retrieve the linearised queue data. */
2664 for( i
= 0; i
< qcount
; i
++) {
2665 uint32 qjob
, qsize
, qpage_count
, qstatus
, qpriority
, qtime
;
2666 len
+= tdb_unpack(data
.dptr
+ len
, data
.dsize
- len
, "ddddddff",
2675 queue
[i
].job
= qjob
;
2676 queue
[i
].size
= qsize
;
2677 queue
[i
].page_count
= qpage_count
;
2678 queue
[i
].status
= qstatus
;
2679 queue
[i
].priority
= qpriority
;
2680 queue
[i
].time
= qtime
;
2683 total_count
= qcount
;
2685 /* Add in the changed jobids. */
2686 for( i
= 0; i
< extra_count
; i
++) {
2688 struct printjob
*pjob
;
2690 jobid
= IVAL(cgdata
.dptr
, i
*4);
2691 DEBUG(5,("get_stored_queue_info: changed job = %u\n", (unsigned int)jobid
));
2692 pjob
= print_job_find(lp_const_servicename(snum
), jobid
);
2694 DEBUG(5,("get_stored_queue_info: failed to find changed job = %u\n", (unsigned int)jobid
));
2695 remove_from_jobs_changed(sharename
, jobid
);
2699 queue
[total_count
].job
= jobid
;
2700 queue
[total_count
].size
= pjob
->size
;
2701 queue
[total_count
].page_count
= pjob
->page_count
;
2702 queue
[total_count
].status
= pjob
->status
;
2703 queue
[total_count
].priority
= 1;
2704 queue
[total_count
].time
= pjob
->starttime
;
2705 fstrcpy(queue
[total_count
].fs_user
, pjob
->user
);
2706 fstrcpy(queue
[total_count
].fs_file
, pjob
->jobname
);
2710 /* Sort the queue by submission time otherwise they are displayed
2713 qsort(queue
, total_count
, sizeof(print_queue_struct
), QSORT_CAST(printjob_comp
));
2715 DEBUG(5,("get_stored_queue_info: total_count = %u\n", (unsigned int)total_count
));
2717 if (max_reported_jobs
&& total_count
> max_reported_jobs
)
2718 total_count
= max_reported_jobs
;
2721 *pcount
= total_count
;
2727 SAFE_FREE(data
.dptr
);
2728 SAFE_FREE(cgdata
.dptr
);
2732 /****************************************************************************
2733 Get a printer queue listing.
2734 set queue = NULL and status = NULL if you just want to update the cache
2735 ****************************************************************************/
2737 int print_queue_status(int snum
,
2738 print_queue_struct
**ppqueue
,
2739 print_status_struct
*status
)
2743 const char *sharename
;
2744 struct tdb_print_db
*pdb
;
2747 /* make sure the database is up to date */
2749 if (print_cache_expired(lp_const_servicename(snum
), True
))
2750 print_queue_update(snum
, False
);
2752 /* return if we are done */
2753 if ( !ppqueue
|| !status
)
2757 sharename
= lp_const_servicename(snum
);
2758 pdb
= get_print_db_byname(sharename
);
2764 * Fetch the queue status. We must do this first, as there may
2765 * be no jobs in the queue.
2768 ZERO_STRUCTP(status
);
2769 slprintf(keystr
, sizeof(keystr
)-1, "STATUS/%s", sharename
);
2770 key
= string_tdb_data(keystr
);
2772 data
= tdb_fetch(pdb
->tdb
, key
);
2774 if (data
.dsize
== sizeof(*status
)) {
2775 /* this memcpy is ok since the status struct was
2776 not packed before storing it in the tdb */
2777 memcpy(status
, data
.dptr
, sizeof(*status
));
2779 SAFE_FREE(data
.dptr
);
2783 * Now, fetch the print queue information. We first count the number
2784 * of entries, and then only retrieve the queue if necessary.
2787 if (!get_stored_queue_info(pdb
, snum
, &count
, ppqueue
)) {
2788 release_print_db(pdb
);
2792 release_print_db(pdb
);
2796 /****************************************************************************
2798 ****************************************************************************/
2800 bool print_queue_pause(struct auth_serversupplied_info
*server_info
, int snum
,
2804 struct printif
*current_printif
= get_printer_fns( snum
);
2806 if (!print_access_check(server_info
, snum
,
2807 PRINTER_ACCESS_ADMINISTER
)) {
2808 *errcode
= WERR_ACCESS_DENIED
;
2815 ret
= (*(current_printif
->queue_pause
))(snum
);
2820 *errcode
= WERR_INVALID_PARAM
;
2824 /* force update the database */
2825 print_cache_flush(lp_const_servicename(snum
));
2827 /* Send a printer notify message */
2829 notify_printer_status(snum
, PRINTER_STATUS_PAUSED
);
2834 /****************************************************************************
2836 ****************************************************************************/
2838 bool print_queue_resume(struct auth_serversupplied_info
*server_info
, int snum
,
2842 struct printif
*current_printif
= get_printer_fns( snum
);
2844 if (!print_access_check(server_info
, snum
,
2845 PRINTER_ACCESS_ADMINISTER
)) {
2846 *errcode
= WERR_ACCESS_DENIED
;
2852 ret
= (*(current_printif
->queue_resume
))(snum
);
2857 *errcode
= WERR_INVALID_PARAM
;
2861 /* make sure the database is up to date */
2862 if (print_cache_expired(lp_const_servicename(snum
), True
))
2863 print_queue_update(snum
, True
);
2865 /* Send a printer notify message */
2867 notify_printer_status(snum
, PRINTER_STATUS_OK
);
2872 /****************************************************************************
2873 Purge a queue - implemented by deleting all jobs that we can delete.
2874 ****************************************************************************/
2876 bool 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
);