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/>.
24 #include "librpc/gen_ndr/messaging.h"
26 extern struct current_user current_user
;
27 extern userdom_struct current_user_info
;
29 /* Current printer interface */
30 static bool remove_from_jobs_changed(const char* sharename
, uint32 jobid
);
33 the printing backend revolves around a tdb database that stores the
34 SMB view of the print queue
36 The key for this database is a jobid - a internally generated number that
37 uniquely identifies a print job
39 reading the print queue involves two steps:
40 - possibly running lpq and updating the internal database from that
41 - reading entries from the database
43 jobids are assigned when a job starts spooling.
46 static TDB_CONTEXT
*rap_tdb
;
47 static uint16 next_rap_jobid
;
48 struct rap_jobid_key
{
53 /***************************************************************************
54 Nightmare. LANMAN jobid's are 16 bit numbers..... We must map them to 32
55 bit RPC jobids.... JRA.
56 ***************************************************************************/
58 uint16
pjobid_to_rap(const char* sharename
, uint32 jobid
)
62 struct rap_jobid_key jinfo
;
65 DEBUG(10,("pjobid_to_rap: called.\n"));
68 /* Create the in-memory tdb. */
69 rap_tdb
= tdb_open_log(NULL
, 0, TDB_INTERNAL
, (O_RDWR
|O_CREAT
), 0644);
75 fstrcpy( jinfo
.sharename
, sharename
);
77 key
.dptr
= (uint8
*)&jinfo
;
78 key
.dsize
= sizeof(jinfo
);
80 data
= tdb_fetch(rap_tdb
, key
);
81 if (data
.dptr
&& data
.dsize
== sizeof(uint16
)) {
82 rap_jobid
= SVAL(data
.dptr
, 0);
84 DEBUG(10,("pjobid_to_rap: jobid %u maps to RAP jobid %u\n",
85 (unsigned int)jobid
, (unsigned int)rap_jobid
));
89 /* Not found - create and store mapping. */
90 rap_jobid
= ++next_rap_jobid
;
92 rap_jobid
= ++next_rap_jobid
;
93 SSVAL(buf
,0,rap_jobid
);
95 data
.dsize
= sizeof(rap_jobid
);
96 tdb_store(rap_tdb
, key
, data
, TDB_REPLACE
);
97 tdb_store(rap_tdb
, data
, key
, TDB_REPLACE
);
99 DEBUG(10,("pjobid_to_rap: created jobid %u maps to RAP jobid %u\n",
100 (unsigned int)jobid
, (unsigned int)rap_jobid
));
104 bool rap_to_pjobid(uint16 rap_jobid
, fstring sharename
, uint32
*pjobid
)
109 DEBUG(10,("rap_to_pjobid called.\n"));
114 SSVAL(buf
,0,rap_jobid
);
116 key
.dsize
= sizeof(rap_jobid
);
117 data
= tdb_fetch(rap_tdb
, key
);
118 if ( data
.dptr
&& data
.dsize
== sizeof(struct rap_jobid_key
) )
120 struct rap_jobid_key
*jinfo
= (struct rap_jobid_key
*)data
.dptr
;
121 if (sharename
!= NULL
) {
122 fstrcpy( sharename
, jinfo
->sharename
);
124 *pjobid
= jinfo
->jobid
;
125 DEBUG(10,("rap_to_pjobid: jobid %u maps to RAP jobid %u\n",
126 (unsigned int)*pjobid
, (unsigned int)rap_jobid
));
127 SAFE_FREE(data
.dptr
);
131 DEBUG(10,("rap_to_pjobid: Failed to lookup RAP jobid %u\n",
132 (unsigned int)rap_jobid
));
133 SAFE_FREE(data
.dptr
);
137 void rap_jobid_delete(const char* sharename
, uint32 jobid
)
141 struct rap_jobid_key jinfo
;
144 DEBUG(10,("rap_jobid_delete: called.\n"));
149 ZERO_STRUCT( jinfo
);
150 fstrcpy( jinfo
.sharename
, sharename
);
152 key
.dptr
= (uint8
*)&jinfo
;
153 key
.dsize
= sizeof(jinfo
);
155 data
= tdb_fetch(rap_tdb
, key
);
156 if (!data
.dptr
|| (data
.dsize
!= sizeof(uint16
))) {
157 DEBUG(10,("rap_jobid_delete: cannot find jobid %u\n",
158 (unsigned int)jobid
));
159 SAFE_FREE(data
.dptr
);
163 DEBUG(10,("rap_jobid_delete: deleting jobid %u\n",
164 (unsigned int)jobid
));
166 rap_jobid
= SVAL(data
.dptr
, 0);
167 SAFE_FREE(data
.dptr
);
168 SSVAL(buf
,0,rap_jobid
);
170 data
.dsize
= sizeof(rap_jobid
);
171 tdb_delete(rap_tdb
, key
);
172 tdb_delete(rap_tdb
, data
);
175 static int get_queue_status(const char* sharename
, print_status_struct
*);
177 /****************************************************************************
178 Initialise the printing backend. Called once at startup before the fork().
179 ****************************************************************************/
181 bool print_backend_init(struct messaging_context
*msg_ctx
)
183 const char *sversion
= "INFO/version";
184 int services
= lp_numservices();
187 unlink(cache_path("printing.tdb"));
188 mkdir(cache_path("printing"),0755);
190 /* handle a Samba upgrade */
192 for (snum
= 0; snum
< services
; snum
++) {
193 struct tdb_print_db
*pdb
;
194 if (!lp_print_ok(snum
))
197 pdb
= get_print_db_byname(lp_const_servicename(snum
));
200 if (tdb_lock_bystring(pdb
->tdb
, sversion
) == -1) {
201 DEBUG(0,("print_backend_init: Failed to open printer %s database\n", lp_const_servicename(snum
) ));
202 release_print_db(pdb
);
205 if (tdb_fetch_int32(pdb
->tdb
, sversion
) != PRINT_DATABASE_VERSION
) {
206 tdb_wipe_all(pdb
->tdb
);
207 tdb_store_int32(pdb
->tdb
, sversion
, PRINT_DATABASE_VERSION
);
209 tdb_unlock_bystring(pdb
->tdb
, sversion
);
210 release_print_db(pdb
);
213 close_all_print_db(); /* Don't leave any open. */
215 /* do NT print initialization... */
216 return nt_printing_init(msg_ctx
);
219 /****************************************************************************
220 Shut down printing backend. Called once at shutdown to close the tdb.
221 ****************************************************************************/
223 void printing_end(void)
225 close_all_print_db(); /* Don't leave any open. */
228 /****************************************************************************
229 Retrieve the set of printing functions for a given service. This allows
230 us to set the printer function table based on the value of the 'printing'
233 Use the generic interface as the default and only use cups interface only
234 when asked for (and only when supported)
235 ****************************************************************************/
237 static struct printif
*get_printer_fns_from_type( enum printing_types type
)
239 struct printif
*printer_fns
= &generic_printif
;
242 if ( type
== PRINT_CUPS
) {
243 printer_fns
= &cups_printif
;
245 #endif /* HAVE_CUPS */
248 if ( type
== PRINT_IPRINT
) {
249 printer_fns
= &iprint_printif
;
251 #endif /* HAVE_IPRINT */
253 printer_fns
->type
= type
;
258 static struct printif
*get_printer_fns( int snum
)
260 return get_printer_fns_from_type( (enum printing_types
)lp_printing(snum
) );
264 /****************************************************************************
265 Useful function to generate a tdb key.
266 ****************************************************************************/
268 static TDB_DATA
print_key(uint32 jobid
, uint32
*tmp
)
272 SIVAL(tmp
, 0, jobid
);
273 ret
.dptr
= (uint8
*)tmp
;
274 ret
.dsize
= sizeof(*tmp
);
278 /***********************************************************************
279 unpack a pjob from a tdb buffer
280 ***********************************************************************/
282 int unpack_pjob( uint8
*buf
, int buflen
, struct printjob
*pjob
)
286 uint32 pjpid
, pjsysjob
, pjfd
, pjstarttime
, pjstatus
;
287 uint32 pjsize
, pjpage_count
, pjspooled
, pjsmbjob
;
292 len
+= tdb_unpack(buf
+len
, buflen
-len
, "dddddddddffff",
310 used
= unpack_devicemode(NULL
, buf
+len
, buflen
-len
, &pjob
->devmode
);
318 pjob
->sysjob
= pjsysjob
;
320 pjob
->starttime
= pjstarttime
;
321 pjob
->status
= pjstatus
;
323 pjob
->page_count
= pjpage_count
;
324 pjob
->spooled
= pjspooled
;
325 pjob
->smbjob
= pjsmbjob
;
331 /****************************************************************************
332 Useful function to find a print job in the database.
333 ****************************************************************************/
335 static struct printjob
*print_job_find(const char *sharename
, uint32 jobid
)
337 static struct printjob pjob
;
340 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
342 DEBUG(10,("print_job_find: looking up job %u for share %s\n",
343 (unsigned int)jobid
, sharename
));
349 ret
= tdb_fetch(pdb
->tdb
, print_key(jobid
, &tmp
));
350 release_print_db(pdb
);
353 DEBUG(10,("print_job_find: failed to find jobid %u.\n", (unsigned int)jobid
));
357 talloc_free(pjob
.devmode
);
361 if ( unpack_pjob( ret
.dptr
, ret
.dsize
, &pjob
) == -1 ) {
362 DEBUG(10,("print_job_find: failed to unpack jobid %u.\n", (unsigned int)jobid
));
369 DEBUG(10,("print_job_find: returning system job %d for jobid %u.\n",
370 (int)pjob
.sysjob
, (unsigned int)jobid
));
375 /* Convert a unix jobid to a smb jobid */
377 struct unixjob_traverse_state
{
379 uint32 sysjob_to_jobid_value
;
382 static int unixjob_traverse_fn(TDB_CONTEXT
*the_tdb
, TDB_DATA key
,
383 TDB_DATA data
, void *private_data
)
385 struct printjob
*pjob
;
386 struct unixjob_traverse_state
*state
=
387 (struct unixjob_traverse_state
*)private_data
;
389 if (!data
.dptr
|| data
.dsize
== 0)
392 pjob
= (struct printjob
*)data
.dptr
;
393 if (key
.dsize
!= sizeof(uint32
))
396 if (state
->sysjob
== pjob
->sysjob
) {
397 uint32 jobid
= IVAL(key
.dptr
,0);
399 state
->sysjob_to_jobid_value
= jobid
;
406 /****************************************************************************
407 This is a *horribly expensive call as we have to iterate through all the
408 current printer tdb's. Don't do this often ! JRA.
409 ****************************************************************************/
411 uint32
sysjob_to_jobid(int unix_jobid
)
413 int services
= lp_numservices();
415 struct unixjob_traverse_state state
;
417 state
.sysjob
= unix_jobid
;
418 state
.sysjob_to_jobid_value
= (uint32
)-1;
420 for (snum
= 0; snum
< services
; snum
++) {
421 struct tdb_print_db
*pdb
;
422 if (!lp_print_ok(snum
))
424 pdb
= get_print_db_byname(lp_const_servicename(snum
));
428 tdb_traverse(pdb
->tdb
, unixjob_traverse_fn
, &state
);
429 release_print_db(pdb
);
430 if (state
.sysjob_to_jobid_value
!= (uint32
)-1)
431 return state
.sysjob_to_jobid_value
;
436 /****************************************************************************
437 Send notifications based on what has changed after a pjob_store.
438 ****************************************************************************/
440 static const struct {
442 uint32 spoolss_status
;
443 } lpq_to_spoolss_status_map
[] = {
444 { LPQ_QUEUED
, JOB_STATUS_QUEUED
},
445 { LPQ_PAUSED
, JOB_STATUS_PAUSED
},
446 { LPQ_SPOOLING
, JOB_STATUS_SPOOLING
},
447 { LPQ_PRINTING
, JOB_STATUS_PRINTING
},
448 { LPQ_DELETING
, JOB_STATUS_DELETING
},
449 { LPQ_OFFLINE
, JOB_STATUS_OFFLINE
},
450 { LPQ_PAPEROUT
, JOB_STATUS_PAPEROUT
},
451 { LPQ_PRINTED
, JOB_STATUS_PRINTED
},
452 { LPQ_DELETED
, JOB_STATUS_DELETED
},
453 { LPQ_BLOCKED
, JOB_STATUS_BLOCKED_DEVQ
},
454 { LPQ_USER_INTERVENTION
, JOB_STATUS_USER_INTERVENTION
},
458 /* Convert a lpq status value stored in printing.tdb into the
459 appropriate win32 API constant. */
461 static uint32
map_to_spoolss_status(uint32 lpq_status
)
465 while (lpq_to_spoolss_status_map
[i
].lpq_status
!= -1) {
466 if (lpq_to_spoolss_status_map
[i
].lpq_status
== lpq_status
)
467 return lpq_to_spoolss_status_map
[i
].spoolss_status
;
474 static void pjob_store_notify(const char* sharename
, uint32 jobid
, struct printjob
*old_data
,
475 struct printjob
*new_data
)
477 bool new_job
= False
;
482 /* Job attributes that can't be changed. We only send
483 notification for these on a new job. */
485 /* ACHTUNG! Due to a bug in Samba's spoolss parsing of the
486 NOTIFY_INFO_DATA buffer, we *have* to send the job submission
487 time first or else we'll end up with potential alignment
488 errors. I don't think the systemtime should be spooled as
489 a string, but this gets us around that error.
490 --jerry (i'll feel dirty for this) */
493 notify_job_submitted(sharename
, jobid
, new_data
->starttime
);
494 notify_job_username(sharename
, jobid
, new_data
->user
);
497 if (new_job
|| !strequal(old_data
->jobname
, new_data
->jobname
))
498 notify_job_name(sharename
, jobid
, new_data
->jobname
);
500 /* Job attributes of a new job or attributes that can be
503 if (new_job
|| !strequal(old_data
->jobname
, new_data
->jobname
))
504 notify_job_name(sharename
, jobid
, new_data
->jobname
);
506 if (new_job
|| old_data
->status
!= new_data
->status
)
507 notify_job_status(sharename
, jobid
, map_to_spoolss_status(new_data
->status
));
509 if (new_job
|| old_data
->size
!= new_data
->size
)
510 notify_job_total_bytes(sharename
, jobid
, new_data
->size
);
512 if (new_job
|| old_data
->page_count
!= new_data
->page_count
)
513 notify_job_total_pages(sharename
, jobid
, new_data
->page_count
);
516 /****************************************************************************
517 Store a job structure back to the database.
518 ****************************************************************************/
520 static bool pjob_store(const char* sharename
, uint32 jobid
, struct printjob
*pjob
)
523 TDB_DATA old_data
, new_data
;
525 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
527 int len
, newlen
, buflen
;
535 old_data
= tdb_fetch(pdb
->tdb
, print_key(jobid
, &tmp
));
537 /* Doh! Now we have to pack/unpack data since the NT_DEVICEMODE was added */
544 len
+= tdb_pack(buf
+len
, buflen
-len
, "dddddddddffff",
546 (uint32
)pjob
->sysjob
,
548 (uint32
)pjob
->starttime
,
549 (uint32
)pjob
->status
,
551 (uint32
)pjob
->page_count
,
552 (uint32
)pjob
->spooled
,
553 (uint32
)pjob
->smbjob
,
559 len
+= pack_devicemode(pjob
->devmode
, buf
+len
, buflen
-len
);
562 buf
= (uint8
*)SMB_REALLOC(buf
, len
);
564 DEBUG(0,("pjob_store: failed to enlarge buffer!\n"));
569 } while ( buflen
!= len
);
575 new_data
.dsize
= len
;
576 ret
= (tdb_store(pdb
->tdb
, print_key(jobid
, &tmp
), new_data
,
579 release_print_db(pdb
);
581 /* Send notify updates for what has changed */
584 struct printjob old_pjob
;
586 if ( old_data
.dsize
)
588 if ( unpack_pjob( old_data
.dptr
, old_data
.dsize
, &old_pjob
) != -1 )
590 pjob_store_notify( sharename
, jobid
, &old_pjob
, pjob
);
591 talloc_free(old_pjob
.devmode
);
596 pjob_store_notify( sharename
, jobid
, NULL
, pjob
);
601 SAFE_FREE( old_data
.dptr
);
607 /****************************************************************************
608 Remove a job structure from the database.
609 ****************************************************************************/
611 void pjob_delete(const char* sharename
, uint32 jobid
)
614 struct printjob
*pjob
;
615 uint32 job_status
= 0;
616 struct tdb_print_db
*pdb
;
618 pdb
= get_print_db_byname( sharename
);
623 pjob
= print_job_find( sharename
, jobid
);
626 DEBUG(5, ("pjob_delete: we were asked to delete nonexistent job %u\n",
627 (unsigned int)jobid
));
628 release_print_db(pdb
);
632 /* We must cycle through JOB_STATUS_DELETING and
633 JOB_STATUS_DELETED for the port monitor to delete the job
636 job_status
= JOB_STATUS_DELETING
|JOB_STATUS_DELETED
;
637 notify_job_status(sharename
, jobid
, job_status
);
639 /* Remove from printing.tdb */
641 tdb_delete(pdb
->tdb
, print_key(jobid
, &tmp
));
642 remove_from_jobs_changed(sharename
, jobid
);
643 release_print_db( pdb
);
644 rap_jobid_delete(sharename
, jobid
);
647 /****************************************************************************
648 List a unix job in the print database.
649 ****************************************************************************/
651 static void print_unix_job(const char *sharename
, print_queue_struct
*q
, uint32 jobid
)
653 struct printjob pj
, *old_pj
;
655 if (jobid
== (uint32
)-1)
656 jobid
= q
->job
+ UNIX_JOB_START
;
658 /* Preserve the timestamp on an existing unix print job */
660 old_pj
= print_job_find(sharename
, jobid
);
667 pj
.starttime
= old_pj
? old_pj
->starttime
: q
->time
;
668 pj
.status
= q
->status
;
671 fstrcpy(pj
.filename
, old_pj
? old_pj
->filename
: "");
672 if (jobid
< UNIX_JOB_START
) {
674 fstrcpy(pj
.jobname
, old_pj
? old_pj
->jobname
: "Remote Downlevel Document");
677 fstrcpy(pj
.jobname
, old_pj
? old_pj
->jobname
: q
->fs_file
);
679 fstrcpy(pj
.user
, old_pj
? old_pj
->user
: q
->fs_user
);
680 fstrcpy(pj
.queuename
, old_pj
? old_pj
->queuename
: sharename
);
682 pjob_store(sharename
, jobid
, &pj
);
686 struct traverse_struct
{
687 print_queue_struct
*queue
;
688 int qcount
, snum
, maxcount
, total_jobs
;
689 const char *sharename
;
691 const char *lprm_command
;
692 struct printif
*print_if
;
695 /****************************************************************************
696 Utility fn to delete any jobs that are no longer active.
697 ****************************************************************************/
699 static int traverse_fn_delete(TDB_CONTEXT
*t
, TDB_DATA key
, TDB_DATA data
, void *state
)
701 struct traverse_struct
*ts
= (struct traverse_struct
*)state
;
702 struct printjob pjob
;
706 if ( key
.dsize
!= sizeof(jobid
) )
709 jobid
= IVAL(key
.dptr
, 0);
710 if ( unpack_pjob( data
.dptr
, data
.dsize
, &pjob
) == -1 )
712 talloc_free(pjob
.devmode
);
716 /* remove a unix job if it isn't in the system queue any more */
718 for (i
=0;i
<ts
->qcount
;i
++) {
719 uint32 u_jobid
= (ts
->queue
[i
].job
+ UNIX_JOB_START
);
720 if (jobid
== u_jobid
)
723 if (i
== ts
->qcount
) {
724 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !smbjob\n",
725 (unsigned int)jobid
));
726 pjob_delete(ts
->sharename
, jobid
);
730 /* need to continue the the bottom of the function to
731 save the correct attributes */
734 /* maybe it hasn't been spooled yet */
736 /* if a job is not spooled and the process doesn't
737 exist then kill it. This cleans up after smbd
739 if (!process_exists_by_pid(pjob
.pid
)) {
740 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !process_exists (%u)\n",
741 (unsigned int)jobid
, (unsigned int)pjob
.pid
));
742 pjob_delete(ts
->sharename
, jobid
);
748 /* this check only makes sense for jobs submitted from Windows clients */
751 for (i
=0;i
<ts
->qcount
;i
++) {
754 if ( pjob
.status
== LPQ_DELETED
)
757 curr_jobid
= print_parse_jobid(ts
->queue
[i
].fs_file
);
759 if (jobid
== curr_jobid
) {
761 /* try to clean up any jobs that need to be deleted */
763 if ( pjob
.status
== LPQ_DELETING
) {
766 result
= (*(ts
->print_if
->job_delete
))(
767 ts
->sharename
, ts
->lprm_command
, &pjob
);
770 /* if we can't delete, then reset the job status */
771 pjob
.status
= LPQ_QUEUED
;
772 pjob_store(ts
->sharename
, jobid
, &pjob
);
775 /* if we deleted the job, the remove the tdb record */
776 pjob_delete(ts
->sharename
, jobid
);
777 pjob
.status
= LPQ_DELETED
;
787 /* The job isn't in the system queue - we have to assume it has
788 completed, so delete the database entry. */
790 if (i
== ts
->qcount
) {
792 /* A race can occur between the time a job is spooled and
793 when it appears in the lpq output. This happens when
794 the job is added to printing.tdb when another smbd
795 running print_queue_update() has completed a lpq and
796 is currently traversing the printing tdb and deleting jobs.
797 Don't delete the job if it was submitted after the lpq_time. */
799 if (pjob
.starttime
< ts
->lpq_time
) {
800 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to pjob.starttime (%u) < ts->lpq_time (%u)\n",
802 (unsigned int)pjob
.starttime
,
803 (unsigned int)ts
->lpq_time
));
804 pjob_delete(ts
->sharename
, jobid
);
810 /* Save the pjob attributes we will store.
811 FIXME!!! This is the only place where queue->job
812 represents the SMB jobid --jerry */
814 ts
->queue
[i
].job
= jobid
;
815 ts
->queue
[i
].size
= pjob
.size
;
816 ts
->queue
[i
].page_count
= pjob
.page_count
;
817 ts
->queue
[i
].status
= pjob
.status
;
818 ts
->queue
[i
].priority
= 1;
819 ts
->queue
[i
].time
= pjob
.starttime
;
820 fstrcpy(ts
->queue
[i
].fs_user
, pjob
.user
);
821 fstrcpy(ts
->queue
[i
].fs_file
, pjob
.jobname
);
828 /****************************************************************************
829 Check if the print queue has been updated recently enough.
830 ****************************************************************************/
832 static void print_cache_flush(const char *sharename
)
835 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
839 slprintf(key
, sizeof(key
)-1, "CACHE/%s", sharename
);
840 tdb_store_int32(pdb
->tdb
, key
, -1);
841 release_print_db(pdb
);
844 /****************************************************************************
845 Check if someone already thinks they are doing the update.
846 ****************************************************************************/
848 static pid_t
get_updating_pid(const char *sharename
)
853 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
857 slprintf(keystr
, sizeof(keystr
)-1, "UPDATING/%s", sharename
);
858 key
= string_tdb_data(keystr
);
860 data
= tdb_fetch(pdb
->tdb
, key
);
861 release_print_db(pdb
);
862 if (!data
.dptr
|| data
.dsize
!= sizeof(pid_t
)) {
863 SAFE_FREE(data
.dptr
);
867 updating_pid
= IVAL(data
.dptr
, 0);
868 SAFE_FREE(data
.dptr
);
870 if (process_exists_by_pid(updating_pid
))
876 /****************************************************************************
877 Set the fact that we're doing the update, or have finished doing the update
879 ****************************************************************************/
881 static void set_updating_pid(const fstring sharename
, bool updating
)
886 pid_t updating_pid
= sys_getpid();
889 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
894 slprintf(keystr
, sizeof(keystr
)-1, "UPDATING/%s", sharename
);
895 key
= string_tdb_data(keystr
);
897 DEBUG(5, ("set_updating_pid: %s updating lpq cache for print share %s\n",
898 updating
? "" : "not ",
902 tdb_delete(pdb
->tdb
, key
);
903 release_print_db(pdb
);
907 SIVAL( buffer
, 0, updating_pid
);
909 data
.dsize
= 4; /* we always assume this is a 4 byte value */
911 tdb_store(pdb
->tdb
, key
, data
, TDB_REPLACE
);
912 release_print_db(pdb
);
915 /****************************************************************************
916 Sort print jobs by submittal time.
917 ****************************************************************************/
919 static int printjob_comp(print_queue_struct
*j1
, print_queue_struct
*j2
)
930 /* Sort on job start time */
932 if (j1
->time
== j2
->time
)
934 return (j1
->time
> j2
->time
) ? 1 : -1;
937 /****************************************************************************
938 Store the sorted queue representation for later portmon retrieval.
940 ****************************************************************************/
942 static void store_queue_struct(struct tdb_print_db
*pdb
, struct traverse_struct
*pts
)
945 int max_reported_jobs
= lp_max_reported_jobs(pts
->snum
);
946 print_queue_struct
*queue
= pts
->queue
;
951 if (max_reported_jobs
&& (max_reported_jobs
< pts
->qcount
))
952 pts
->qcount
= max_reported_jobs
;
955 /* Work out the size. */
957 data
.dsize
+= tdb_pack(NULL
, 0, "d", qcount
);
959 for (i
= 0; i
< pts
->qcount
; i
++) {
960 if ( queue
[i
].status
== LPQ_DELETED
)
964 data
.dsize
+= tdb_pack(NULL
, 0, "ddddddff",
965 (uint32
)queue
[i
].job
,
966 (uint32
)queue
[i
].size
,
967 (uint32
)queue
[i
].page_count
,
968 (uint32
)queue
[i
].status
,
969 (uint32
)queue
[i
].priority
,
970 (uint32
)queue
[i
].time
,
975 if ((data
.dptr
= (uint8
*)SMB_MALLOC(data
.dsize
)) == NULL
)
979 len
+= tdb_pack(data
.dptr
+ len
, data
.dsize
- len
, "d", qcount
);
980 for (i
= 0; i
< pts
->qcount
; i
++) {
981 if ( queue
[i
].status
== LPQ_DELETED
)
984 len
+= tdb_pack(data
.dptr
+ len
, data
.dsize
- len
, "ddddddff",
985 (uint32
)queue
[i
].job
,
986 (uint32
)queue
[i
].size
,
987 (uint32
)queue
[i
].page_count
,
988 (uint32
)queue
[i
].status
,
989 (uint32
)queue
[i
].priority
,
990 (uint32
)queue
[i
].time
,
995 tdb_store(pdb
->tdb
, string_tdb_data("INFO/linear_queue_array"), data
,
997 SAFE_FREE(data
.dptr
);
1001 static TDB_DATA
get_jobs_changed_data(struct tdb_print_db
*pdb
)
1007 data
= tdb_fetch(pdb
->tdb
, string_tdb_data("INFO/jobs_changed"));
1008 if (data
.dptr
== NULL
|| data
.dsize
== 0 || (data
.dsize
% 4 != 0)) {
1009 SAFE_FREE(data
.dptr
);
1016 static void check_job_changed(const char *sharename
, TDB_DATA data
, uint32 jobid
)
1019 unsigned int job_count
= data
.dsize
/ 4;
1021 for (i
= 0; i
< job_count
; i
++) {
1024 ch_jobid
= IVAL(data
.dptr
, i
*4);
1025 if (ch_jobid
== jobid
)
1026 remove_from_jobs_changed(sharename
, jobid
);
1030 /****************************************************************************
1031 Check if the print queue has been updated recently enough.
1032 ****************************************************************************/
1034 static bool print_cache_expired(const char *sharename
, bool check_pending
)
1037 time_t last_qscan_time
, time_now
= time(NULL
);
1038 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1039 bool result
= False
;
1044 snprintf(key
, sizeof(key
), "CACHE/%s", sharename
);
1045 last_qscan_time
= (time_t)tdb_fetch_int32(pdb
->tdb
, key
);
1048 * Invalidate the queue for 3 reasons.
1049 * (1). last queue scan time == -1.
1050 * (2). Current time - last queue scan time > allowed cache time.
1051 * (3). last queue scan time > current time + MAX_CACHE_VALID_TIME (1 hour by default).
1052 * This last test picks up machines for which the clock has been moved
1053 * forward, an lpq scan done and then the clock moved back. Otherwise
1054 * that last lpq scan would stay around for a loooong loooong time... :-). JRA.
1057 if (last_qscan_time
== ((time_t)-1)
1058 || (time_now
- last_qscan_time
) >= lp_lpqcachetime()
1059 || last_qscan_time
> (time_now
+ MAX_CACHE_VALID_TIME
))
1062 time_t msg_pending_time
;
1064 DEBUG(4, ("print_cache_expired: cache expired for queue %s "
1065 "(last_qscan_time = %d, time now = %d, qcachetime = %d)\n",
1066 sharename
, (int)last_qscan_time
, (int)time_now
,
1067 (int)lp_lpqcachetime() ));
1069 /* check if another smbd has already sent a message to update the
1070 queue. Give the pending message one minute to clear and
1071 then send another message anyways. Make sure to check for
1072 clocks that have been run forward and then back again. */
1074 snprintf(key
, sizeof(key
), "MSG_PENDING/%s", sharename
);
1077 && tdb_fetch_uint32( pdb
->tdb
, key
, &u
)
1078 && (msg_pending_time
=u
) > 0
1079 && msg_pending_time
<= time_now
1080 && (time_now
- msg_pending_time
) < 60 )
1082 DEBUG(4,("print_cache_expired: message already pending for %s. Accepting cache\n",
1091 release_print_db(pdb
);
1095 /****************************************************************************
1096 main work for updating the lpq cahe for a printer queue
1097 ****************************************************************************/
1099 static void print_queue_update_internal( const char *sharename
,
1100 struct printif
*current_printif
,
1101 char *lpq_command
, char *lprm_command
)
1104 print_queue_struct
*queue
= NULL
;
1105 print_status_struct status
;
1106 print_status_struct old_status
;
1107 struct printjob
*pjob
;
1108 struct traverse_struct tstruct
;
1111 fstring keystr
, cachestr
;
1112 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1118 DEBUG(5,("print_queue_update_internal: printer = %s, type = %d, lpq command = [%s]\n",
1119 sharename
, current_printif
->type
, lpq_command
));
1122 * Update the cache time FIRST ! Stops others even
1123 * attempting to get the lock and doing this
1124 * if the lpq takes a long time.
1127 slprintf(cachestr
, sizeof(cachestr
)-1, "CACHE/%s", sharename
);
1128 tdb_store_int32(pdb
->tdb
, cachestr
, (int)time(NULL
));
1130 /* get the current queue using the appropriate interface */
1131 ZERO_STRUCT(status
);
1133 qcount
= (*(current_printif
->queue_get
))(sharename
,
1134 current_printif
->type
,
1135 lpq_command
, &queue
, &status
);
1137 DEBUG(3, ("print_queue_update_internal: %d job%s in queue for %s\n",
1138 qcount
, (qcount
!= 1) ? "s" : "", sharename
));
1140 /* Sort the queue by submission time otherwise they are displayed
1143 TYPESAFE_QSORT(queue
, qcount
, printjob_comp
);
1146 any job in the internal database that is marked as spooled
1147 and doesn't exist in the system queue is considered finished
1148 and removed from the database
1150 any job in the system database but not in the internal database
1151 is added as a unix job
1153 fill in any system job numbers as we go
1156 jcdata
= get_jobs_changed_data(pdb
);
1158 for (i
=0; i
<qcount
; i
++) {
1159 uint32 jobid
= print_parse_jobid(queue
[i
].fs_file
);
1161 if (jobid
== (uint32
)-1) {
1162 /* assume its a unix print job */
1163 print_unix_job(sharename
, &queue
[i
], jobid
);
1167 /* we have an active SMB print job - update its status */
1168 pjob
= print_job_find(sharename
, jobid
);
1170 /* err, somethings wrong. Probably smbd was restarted
1171 with jobs in the queue. All we can do is treat them
1172 like unix jobs. Pity. */
1173 print_unix_job(sharename
, &queue
[i
], jobid
);
1177 pjob
->sysjob
= queue
[i
].job
;
1179 /* don't reset the status on jobs to be deleted */
1181 if ( pjob
->status
!= LPQ_DELETING
)
1182 pjob
->status
= queue
[i
].status
;
1184 pjob_store(sharename
, jobid
, pjob
);
1186 check_job_changed(sharename
, jcdata
, jobid
);
1189 SAFE_FREE(jcdata
.dptr
);
1191 /* now delete any queued entries that don't appear in the
1193 tstruct
.queue
= queue
;
1194 tstruct
.qcount
= qcount
;
1196 tstruct
.total_jobs
= 0;
1197 tstruct
.lpq_time
= time(NULL
);
1198 tstruct
.sharename
= sharename
;
1199 tstruct
.lprm_command
= lprm_command
;
1200 tstruct
.print_if
= current_printif
;
1202 tdb_traverse(pdb
->tdb
, traverse_fn_delete
, (void *)&tstruct
);
1204 /* Store the linearised queue, max jobs only. */
1205 store_queue_struct(pdb
, &tstruct
);
1207 SAFE_FREE(tstruct
.queue
);
1209 DEBUG(10,("print_queue_update_internal: printer %s INFO/total_jobs = %d\n",
1210 sharename
, tstruct
.total_jobs
));
1212 tdb_store_int32(pdb
->tdb
, "INFO/total_jobs", tstruct
.total_jobs
);
1214 get_queue_status(sharename
, &old_status
);
1215 if (old_status
.qcount
!= qcount
)
1216 DEBUG(10,("print_queue_update_internal: queue status change %d jobs -> %d jobs for printer %s\n",
1217 old_status
.qcount
, qcount
, sharename
));
1219 /* store the new queue status structure */
1220 slprintf(keystr
, sizeof(keystr
)-1, "STATUS/%s", sharename
);
1221 key
= string_tdb_data(keystr
);
1223 status
.qcount
= qcount
;
1224 data
.dptr
= (uint8
*)&status
;
1225 data
.dsize
= sizeof(status
);
1226 tdb_store(pdb
->tdb
, key
, data
, TDB_REPLACE
);
1229 * Update the cache time again. We want to do this call
1230 * as little as possible...
1233 slprintf(keystr
, sizeof(keystr
)-1, "CACHE/%s", sharename
);
1234 tdb_store_int32(pdb
->tdb
, keystr
, (int32
)time(NULL
));
1236 /* clear the msg pending record for this queue */
1238 snprintf(keystr
, sizeof(keystr
), "MSG_PENDING/%s", sharename
);
1240 if ( !tdb_store_uint32( pdb
->tdb
, keystr
, 0 ) ) {
1241 /* log a message but continue on */
1243 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1247 release_print_db( pdb
);
1252 /****************************************************************************
1253 Update the internal database from the system print queue for a queue.
1254 obtain a lock on the print queue before proceeding (needed when mutiple
1255 smbd processes maytry to update the lpq cache concurrently).
1256 ****************************************************************************/
1258 static void print_queue_update_with_lock( const char *sharename
,
1259 struct printif
*current_printif
,
1260 char *lpq_command
, char *lprm_command
)
1263 struct tdb_print_db
*pdb
;
1265 DEBUG(5,("print_queue_update_with_lock: printer share = %s\n", sharename
));
1266 pdb
= get_print_db_byname(sharename
);
1270 if ( !print_cache_expired(sharename
, False
) ) {
1271 DEBUG(5,("print_queue_update_with_lock: print cache for %s is still ok\n", sharename
));
1272 release_print_db(pdb
);
1277 * Check to see if someone else is doing this update.
1278 * This is essentially a mutex on the update.
1281 if (get_updating_pid(sharename
) != -1) {
1282 release_print_db(pdb
);
1286 /* Lock the queue for the database update */
1288 slprintf(keystr
, sizeof(keystr
) - 1, "LOCK/%s", sharename
);
1289 /* Only wait 10 seconds for this. */
1290 if (tdb_lock_bystring_with_timeout(pdb
->tdb
, keystr
, 10) == -1) {
1291 DEBUG(0,("print_queue_update_with_lock: Failed to lock printer %s database\n", sharename
));
1292 release_print_db(pdb
);
1297 * Ensure that no one else got in here.
1298 * If the updating pid is still -1 then we are
1302 if (get_updating_pid(sharename
) != -1) {
1304 * Someone else is doing the update, exit.
1306 tdb_unlock_bystring(pdb
->tdb
, keystr
);
1307 release_print_db(pdb
);
1312 * We're going to do the update ourselves.
1315 /* Tell others we're doing the update. */
1316 set_updating_pid(sharename
, True
);
1319 * Allow others to enter and notice we're doing
1323 tdb_unlock_bystring(pdb
->tdb
, keystr
);
1325 /* do the main work now */
1327 print_queue_update_internal( sharename
, current_printif
,
1328 lpq_command
, lprm_command
);
1330 /* Delete our pid from the db. */
1331 set_updating_pid(sharename
, False
);
1332 release_print_db(pdb
);
1335 /****************************************************************************
1336 this is the receive function of the background lpq updater
1337 ****************************************************************************/
1338 static void print_queue_receive(struct messaging_context
*msg
,
1341 struct server_id server_id
,
1345 char *lpqcommand
= NULL
, *lprmcommand
= NULL
;
1349 len
= tdb_unpack( (uint8
*)data
->data
, data
->length
, "fdPP",
1356 SAFE_FREE(lpqcommand
);
1357 SAFE_FREE(lprmcommand
);
1358 DEBUG(0,("print_queue_receive: Got invalid print queue update message\n"));
1362 print_queue_update_with_lock(sharename
,
1363 get_printer_fns_from_type((enum printing_types
)printing_type
),
1364 lpqcommand
, lprmcommand
);
1366 SAFE_FREE(lpqcommand
);
1367 SAFE_FREE(lprmcommand
);
1371 static void printing_pause_fd_handler(struct tevent_context
*ev
,
1372 struct tevent_fd
*fde
,
1377 * If pause_pipe[1] is closed it means the parent smbd
1378 * and children exited or aborted.
1380 exit_server_cleanly(NULL
);
1383 extern struct child_pid
*children
;
1384 extern int num_children
;
1386 static void add_child_pid(pid_t pid
)
1388 struct child_pid
*child
;
1390 child
= SMB_MALLOC_P(struct child_pid
);
1391 if (child
== NULL
) {
1392 DEBUG(0, ("Could not add child struct -- malloc failed\n"));
1396 DLIST_ADD(children
, child
);
1400 static pid_t background_lpq_updater_pid
= -1;
1402 /****************************************************************************
1403 main thread of the background lpq updater
1404 ****************************************************************************/
1405 void start_background_queue(void)
1407 /* Use local variables for this as we don't
1408 * need to save the parent side of this, just
1409 * ensure it closes when the process exits.
1413 DEBUG(3,("start_background_queue: Starting background LPQ thread\n"));
1415 if (pipe(pause_pipe
) == -1) {
1416 DEBUG(5,("start_background_queue: cannot create pipe. %s\n", strerror(errno
) ));
1420 background_lpq_updater_pid
= sys_fork();
1422 if (background_lpq_updater_pid
== -1) {
1423 DEBUG(5,("start_background_queue: background LPQ thread failed to start. %s\n", strerror(errno
) ));
1427 /* Track the printing pid along with other smbd children */
1428 add_child_pid(background_lpq_updater_pid
);
1430 if(background_lpq_updater_pid
== 0) {
1431 struct tevent_fd
*fde
;
1436 DEBUG(5,("start_background_queue: background LPQ thread started\n"));
1438 close(pause_pipe
[0]);
1441 status
= reinit_after_fork(server_messaging_context(),
1442 server_event_context(),
1443 procid_self(), true);
1445 if (!NT_STATUS_IS_OK(status
)) {
1446 DEBUG(0,("reinit_after_fork() failed\n"));
1447 smb_panic("reinit_after_fork() failed");
1450 smbd_setup_sig_term_handler();
1451 smbd_setup_sig_hup_handler();
1453 if (!serverid_register(procid_self(),
1454 FLAG_MSG_GENERAL
|FLAG_MSG_SMBD
1455 |FLAG_MSG_PRINT_GENERAL
)) {
1459 if (!locking_init()) {
1463 messaging_register(server_messaging_context(), NULL
,
1464 MSG_PRINTER_UPDATE
, print_queue_receive
);
1466 fde
= tevent_add_fd(server_event_context(),
1467 server_event_context(),
1468 pause_pipe
[1], TEVENT_FD_READ
,
1469 printing_pause_fd_handler
,
1472 DEBUG(0,("tevent_add_fd() failed for pause_pipe\n"));
1473 smb_panic("tevent_add_fd() failed for pause_pipe");
1476 DEBUG(5,("start_background_queue: background LPQ thread waiting for messages\n"));
1477 ret
= tevent_loop_wait(server_event_context());
1478 /* should not be reached */
1479 DEBUG(0,("background_queue: tevent_loop_wait() exited with %d - %s\n",
1480 ret
, (ret
== 0) ? "out of events" : strerror(errno
)));
1484 close(pause_pipe
[1]);
1487 /****************************************************************************
1488 update the internal database from the system print queue for a queue
1489 ****************************************************************************/
1491 static void print_queue_update(int snum
, bool force
)
1495 char *lpqcommand
= NULL
;
1496 char *lprmcommand
= NULL
;
1497 uint8
*buffer
= NULL
;
1500 struct tdb_print_db
*pdb
;
1502 struct printif
*current_printif
;
1503 TALLOC_CTX
*ctx
= talloc_tos();
1505 fstrcpy( sharename
, lp_const_servicename(snum
));
1507 /* don't strip out characters like '$' from the printername */
1509 lpqcommand
= talloc_string_sub2(ctx
,
1510 lp_lpqcommand(snum
),
1512 lp_printername(snum
),
1513 false, false, false);
1517 lpqcommand
= talloc_sub_advanced(ctx
,
1518 lp_servicename(snum
),
1519 current_user_info
.unix_name
,
1521 current_user
.ut
.gid
,
1522 get_current_username(),
1523 current_user_info
.domain
,
1529 lprmcommand
= talloc_string_sub2(ctx
,
1530 lp_lprmcommand(snum
),
1532 lp_printername(snum
),
1533 false, false, false);
1537 lprmcommand
= talloc_sub_advanced(ctx
,
1538 lp_servicename(snum
),
1539 current_user_info
.unix_name
,
1541 current_user
.ut
.gid
,
1542 get_current_username(),
1543 current_user_info
.domain
,
1550 * Make sure that the background queue process exists.
1551 * Otherwise just do the update ourselves
1554 if ( force
|| background_lpq_updater_pid
== -1 ) {
1555 DEBUG(4,("print_queue_update: updating queue [%s] myself\n", sharename
));
1556 current_printif
= get_printer_fns( snum
);
1557 print_queue_update_with_lock( sharename
, current_printif
, lpqcommand
, lprmcommand
);
1562 type
= lp_printing(snum
);
1564 /* get the length */
1566 len
= tdb_pack( NULL
, 0, "fdPP",
1572 buffer
= SMB_XMALLOC_ARRAY( uint8
, len
);
1574 /* now pack the buffer */
1575 newlen
= tdb_pack( buffer
, len
, "fdPP",
1581 SMB_ASSERT( newlen
== len
);
1583 DEBUG(10,("print_queue_update: Sending message -> printer = %s, "
1584 "type = %d, lpq command = [%s] lprm command = [%s]\n",
1585 sharename
, type
, lpqcommand
, lprmcommand
));
1587 /* here we set a msg pending record for other smbd processes
1588 to throttle the number of duplicate print_queue_update msgs
1591 pdb
= get_print_db_byname(sharename
);
1597 snprintf(key
, sizeof(key
), "MSG_PENDING/%s", sharename
);
1599 if ( !tdb_store_uint32( pdb
->tdb
, key
, time(NULL
) ) ) {
1600 /* log a message but continue on */
1602 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1606 release_print_db( pdb
);
1608 /* finally send the message */
1610 messaging_send_buf(server_messaging_context(),
1611 pid_to_procid(background_lpq_updater_pid
),
1612 MSG_PRINTER_UPDATE
, (uint8
*)buffer
, len
);
1614 SAFE_FREE( buffer
);
1619 /****************************************************************************
1620 Create/Update an entry in the print tdb that will allow us to send notify
1621 updates only to interested smbd's.
1622 ****************************************************************************/
1624 bool print_notify_register_pid(int snum
)
1627 struct tdb_print_db
*pdb
= NULL
;
1628 TDB_CONTEXT
*tdb
= NULL
;
1629 const char *printername
;
1630 uint32 mypid
= (uint32
)sys_getpid();
1634 /* if (snum == -1), then the change notify request was
1635 on a print server handle and we need to register on
1640 int num_services
= lp_numservices();
1643 for ( idx
=0; idx
<num_services
; idx
++ ) {
1644 if (lp_snum_ok(idx
) && lp_print_ok(idx
) )
1645 print_notify_register_pid(idx
);
1650 else /* register for a specific printer */
1652 printername
= lp_const_servicename(snum
);
1653 pdb
= get_print_db_byname(printername
);
1659 if (tdb_lock_bystring_with_timeout(tdb
, NOTIFY_PID_LIST_KEY
, 10) == -1) {
1660 DEBUG(0,("print_notify_register_pid: Failed to lock printer %s\n",
1663 release_print_db(pdb
);
1667 data
= get_printer_notify_pid_list( tdb
, printername
, True
);
1669 /* Add ourselves and increase the refcount. */
1671 for (i
= 0; i
< data
.dsize
; i
+= 8) {
1672 if (IVAL(data
.dptr
,i
) == mypid
) {
1673 uint32 new_refcount
= IVAL(data
.dptr
, i
+4) + 1;
1674 SIVAL(data
.dptr
, i
+4, new_refcount
);
1679 if (i
== data
.dsize
) {
1680 /* We weren't in the list. Realloc. */
1681 data
.dptr
= (uint8
*)SMB_REALLOC(data
.dptr
, data
.dsize
+ 8);
1683 DEBUG(0,("print_notify_register_pid: Relloc fail for printer %s\n",
1688 SIVAL(data
.dptr
,data
.dsize
- 8,mypid
);
1689 SIVAL(data
.dptr
,data
.dsize
- 4,1); /* Refcount. */
1692 /* Store back the record. */
1693 if (tdb_store_bystring(tdb
, NOTIFY_PID_LIST_KEY
, data
, TDB_REPLACE
) == -1) {
1694 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1695 list for printer %s\n", printername
));
1703 tdb_unlock_bystring(tdb
, NOTIFY_PID_LIST_KEY
);
1705 release_print_db(pdb
);
1706 SAFE_FREE(data
.dptr
);
1710 /****************************************************************************
1711 Update an entry in the print tdb that will allow us to send notify
1712 updates only to interested smbd's.
1713 ****************************************************************************/
1715 bool print_notify_deregister_pid(int snum
)
1718 struct tdb_print_db
*pdb
= NULL
;
1719 TDB_CONTEXT
*tdb
= NULL
;
1720 const char *printername
;
1721 uint32 mypid
= (uint32
)sys_getpid();
1725 /* if ( snum == -1 ), we are deregister a print server handle
1726 which means to deregister on all print queues */
1730 int num_services
= lp_numservices();
1733 for ( idx
=0; idx
<num_services
; idx
++ ) {
1734 if ( lp_snum_ok(idx
) && lp_print_ok(idx
) )
1735 print_notify_deregister_pid(idx
);
1740 else /* deregister a specific printer */
1742 printername
= lp_const_servicename(snum
);
1743 pdb
= get_print_db_byname(printername
);
1749 if (tdb_lock_bystring_with_timeout(tdb
, NOTIFY_PID_LIST_KEY
, 10) == -1) {
1750 DEBUG(0,("print_notify_register_pid: Failed to lock \
1751 printer %s database\n", printername
));
1753 release_print_db(pdb
);
1757 data
= get_printer_notify_pid_list( tdb
, printername
, True
);
1759 /* Reduce refcount. Remove ourselves if zero. */
1761 for (i
= 0; i
< data
.dsize
; ) {
1762 if (IVAL(data
.dptr
,i
) == mypid
) {
1763 uint32 refcount
= IVAL(data
.dptr
, i
+4);
1767 if (refcount
== 0) {
1768 if (data
.dsize
- i
> 8)
1769 memmove( &data
.dptr
[i
], &data
.dptr
[i
+8], data
.dsize
- i
- 8);
1773 SIVAL(data
.dptr
, i
+4, refcount
);
1779 if (data
.dsize
== 0)
1780 SAFE_FREE(data
.dptr
);
1782 /* Store back the record. */
1783 if (tdb_store_bystring(tdb
, NOTIFY_PID_LIST_KEY
, data
, TDB_REPLACE
) == -1) {
1784 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1785 list for printer %s\n", printername
));
1793 tdb_unlock_bystring(tdb
, NOTIFY_PID_LIST_KEY
);
1795 release_print_db(pdb
);
1796 SAFE_FREE(data
.dptr
);
1800 /****************************************************************************
1801 Check if a jobid is valid. It is valid if it exists in the database.
1802 ****************************************************************************/
1804 bool print_job_exists(const char* sharename
, uint32 jobid
)
1806 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1812 ret
= tdb_exists(pdb
->tdb
, print_key(jobid
, &tmp
));
1813 release_print_db(pdb
);
1817 /****************************************************************************
1818 Give the fd used for a jobid.
1819 ****************************************************************************/
1821 int print_job_fd(const char* sharename
, uint32 jobid
)
1823 struct printjob
*pjob
= print_job_find(sharename
, jobid
);
1826 /* don't allow another process to get this info - it is meaningless */
1827 if (pjob
->pid
!= sys_getpid())
1832 /****************************************************************************
1833 Give the filename used for a jobid.
1834 Only valid for the process doing the spooling and when the job
1835 has not been spooled.
1836 ****************************************************************************/
1838 char *print_job_fname(const char* sharename
, uint32 jobid
)
1840 struct printjob
*pjob
= print_job_find(sharename
, jobid
);
1841 if (!pjob
|| pjob
->spooled
|| pjob
->pid
!= sys_getpid())
1843 return pjob
->filename
;
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 struct spoolss_DeviceMode
*print_job_devmode(const char* sharename
, uint32 jobid
)
1855 struct printjob
*pjob
= print_job_find(sharename
, jobid
);
1860 return pjob
->devmode
;
1863 /****************************************************************************
1864 Set the name of a job. Only possible for owner.
1865 ****************************************************************************/
1867 bool print_job_set_name(const char *sharename
, uint32 jobid
, const char *name
)
1869 struct printjob
*pjob
;
1871 pjob
= print_job_find(sharename
, jobid
);
1872 if (!pjob
|| pjob
->pid
!= sys_getpid())
1875 fstrcpy(pjob
->jobname
, name
);
1876 return pjob_store(sharename
, jobid
, pjob
);
1879 /****************************************************************************
1880 Get the name of a job. Only possible for owner.
1881 ****************************************************************************/
1883 bool print_job_get_name(TALLOC_CTX
*mem_ctx
, const char *sharename
, uint32_t jobid
, char **name
)
1885 struct printjob
*pjob
;
1887 pjob
= print_job_find(sharename
, jobid
);
1888 if (!pjob
|| pjob
->pid
!= sys_getpid()) {
1892 *name
= talloc_strdup(mem_ctx
, pjob
->jobname
);
1901 /***************************************************************************
1902 Remove a jobid from the 'jobs changed' list.
1903 ***************************************************************************/
1905 static bool remove_from_jobs_changed(const char* sharename
, uint32 jobid
)
1907 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1909 size_t job_count
, i
;
1911 bool gotlock
= False
;
1919 key
= string_tdb_data("INFO/jobs_changed");
1921 if (tdb_chainlock_with_timeout(pdb
->tdb
, key
, 5) == -1)
1926 data
= tdb_fetch(pdb
->tdb
, key
);
1928 if (data
.dptr
== NULL
|| data
.dsize
== 0 || (data
.dsize
% 4 != 0))
1931 job_count
= data
.dsize
/ 4;
1932 for (i
= 0; i
< job_count
; i
++) {
1935 ch_jobid
= IVAL(data
.dptr
, i
*4);
1936 if (ch_jobid
== jobid
) {
1937 if (i
< job_count
-1 )
1938 memmove(data
.dptr
+ (i
*4), data
.dptr
+ (i
*4) + 4, (job_count
- i
- 1)*4 );
1940 if (tdb_store(pdb
->tdb
, key
, data
, TDB_REPLACE
) == -1)
1950 tdb_chainunlock(pdb
->tdb
, key
);
1951 SAFE_FREE(data
.dptr
);
1952 release_print_db(pdb
);
1954 DEBUG(10,("remove_from_jobs_changed: removed jobid %u\n", (unsigned int)jobid
));
1956 DEBUG(10,("remove_from_jobs_changed: Failed to remove jobid %u\n", (unsigned int)jobid
));
1960 /****************************************************************************
1961 Delete a print job - don't update queue.
1962 ****************************************************************************/
1964 static bool print_job_delete1(int snum
, uint32 jobid
)
1966 const char* sharename
= lp_const_servicename(snum
);
1967 struct printjob
*pjob
= print_job_find(sharename
, jobid
);
1969 struct printif
*current_printif
= get_printer_fns( snum
);
1975 * If already deleting just return.
1978 if (pjob
->status
== LPQ_DELETING
)
1981 /* Hrm - we need to be able to cope with deleting a job before it
1982 has reached the spooler. Just mark it as LPQ_DELETING and
1983 let the print_queue_update() code rmeove the record */
1986 if (pjob
->sysjob
== -1) {
1987 DEBUG(5, ("attempt to delete job %u not seen by lpr\n", (unsigned int)jobid
));
1990 /* Set the tdb entry to be deleting. */
1992 pjob
->status
= LPQ_DELETING
;
1993 pjob_store(sharename
, jobid
, pjob
);
1995 if (pjob
->spooled
&& pjob
->sysjob
!= -1)
1997 result
= (*(current_printif
->job_delete
))(
1998 lp_printername(snum
),
1999 lp_lprmcommand(snum
),
2002 /* Delete the tdb entry if the delete succeeded or the job hasn't
2006 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
2011 pjob_delete(sharename
, jobid
);
2012 /* Ensure we keep a rough count of the number of total jobs... */
2013 tdb_change_int32_atomic(pdb
->tdb
, "INFO/total_jobs", &njobs
, -1);
2014 release_print_db(pdb
);
2018 remove_from_jobs_changed( sharename
, jobid
);
2020 return (result
== 0);
2023 /****************************************************************************
2024 Return true if the current user owns the print job.
2025 ****************************************************************************/
2027 static bool is_owner(struct auth_serversupplied_info
*server_info
,
2028 const char *servicename
,
2031 struct printjob
*pjob
= print_job_find(servicename
, jobid
);
2033 if (!pjob
|| !server_info
)
2036 return strequal(pjob
->user
, server_info
->sanitized_username
);
2039 /****************************************************************************
2041 ****************************************************************************/
2043 bool print_job_delete(struct auth_serversupplied_info
*server_info
, int snum
,
2044 uint32 jobid
, WERROR
*errcode
)
2046 const char* sharename
= lp_const_servicename( snum
);
2047 struct printjob
*pjob
;
2053 owner
= is_owner(server_info
, lp_const_servicename(snum
), jobid
);
2055 /* Check access against security descriptor or whether the user
2059 !print_access_check(server_info
, snum
, JOB_ACCESS_ADMINISTER
)) {
2060 DEBUG(3, ("delete denied by security descriptor\n"));
2061 *errcode
= WERR_ACCESS_DENIED
;
2063 /* BEGIN_ADMIN_LOG */
2064 sys_adminlog( LOG_ERR
,
2065 "Permission denied-- user not allowed to delete, \
2066 pause, or resume print job. User name: %s. Printer name: %s.",
2067 uidtoname(server_info
->utok
.uid
),
2068 lp_printername(snum
) );
2075 * get the spooled filename of the print job
2076 * if this works, then the file has not been spooled
2077 * to the underlying print system. Just delete the
2078 * spool file & return.
2081 if ( (fname
= print_job_fname( sharename
, jobid
)) != NULL
)
2083 /* remove the spool file */
2084 DEBUG(10,("print_job_delete: Removing spool file [%s]\n", fname
));
2085 if ( unlink( fname
) == -1 ) {
2086 *errcode
= map_werror_from_unix(errno
);
2091 if (!print_job_delete1(snum
, jobid
)) {
2092 *errcode
= WERR_ACCESS_DENIED
;
2096 /* force update the database and say the delete failed if the
2099 print_queue_update(snum
, True
);
2101 pjob
= print_job_find(sharename
, jobid
);
2102 if ( pjob
&& (pjob
->status
!= LPQ_DELETING
) )
2103 *errcode
= WERR_ACCESS_DENIED
;
2105 return (pjob
== NULL
);
2108 /****************************************************************************
2110 ****************************************************************************/
2112 bool print_job_pause(struct auth_serversupplied_info
*server_info
, int snum
,
2113 uint32 jobid
, WERROR
*errcode
)
2115 const char* sharename
= lp_const_servicename(snum
);
2116 struct printjob
*pjob
;
2118 struct printif
*current_printif
= get_printer_fns( snum
);
2120 pjob
= print_job_find(sharename
, jobid
);
2122 if (!pjob
|| !server_info
) {
2123 DEBUG(10, ("print_job_pause: no pjob or user for jobid %u\n",
2124 (unsigned int)jobid
));
2128 if (!pjob
->spooled
|| pjob
->sysjob
== -1) {
2129 DEBUG(10, ("print_job_pause: not spooled or bad sysjob = %d for jobid %u\n",
2130 (int)pjob
->sysjob
, (unsigned int)jobid
));
2134 if (!is_owner(server_info
, lp_const_servicename(snum
), jobid
) &&
2135 !print_access_check(server_info
, snum
, JOB_ACCESS_ADMINISTER
)) {
2136 DEBUG(3, ("pause denied by security descriptor\n"));
2138 /* BEGIN_ADMIN_LOG */
2139 sys_adminlog( LOG_ERR
,
2140 "Permission denied-- user not allowed to delete, \
2141 pause, or resume print job. User name: %s. Printer name: %s.",
2142 uidtoname(server_info
->utok
.uid
),
2143 lp_printername(snum
) );
2146 *errcode
= WERR_ACCESS_DENIED
;
2150 /* need to pause the spooled entry */
2151 ret
= (*(current_printif
->job_pause
))(snum
, pjob
);
2154 *errcode
= WERR_INVALID_PARAM
;
2158 /* force update the database */
2159 print_cache_flush(lp_const_servicename(snum
));
2161 /* Send a printer notify message */
2163 notify_job_status(sharename
, jobid
, JOB_STATUS_PAUSED
);
2165 /* how do we tell if this succeeded? */
2170 /****************************************************************************
2172 ****************************************************************************/
2174 bool print_job_resume(struct auth_serversupplied_info
*server_info
, int snum
,
2175 uint32 jobid
, WERROR
*errcode
)
2177 const char *sharename
= lp_const_servicename(snum
);
2178 struct printjob
*pjob
;
2180 struct printif
*current_printif
= get_printer_fns( snum
);
2182 pjob
= print_job_find(sharename
, jobid
);
2184 if (!pjob
|| !server_info
) {
2185 DEBUG(10, ("print_job_resume: no pjob or user for jobid %u\n",
2186 (unsigned int)jobid
));
2190 if (!pjob
->spooled
|| pjob
->sysjob
== -1) {
2191 DEBUG(10, ("print_job_resume: not spooled or bad sysjob = %d for jobid %u\n",
2192 (int)pjob
->sysjob
, (unsigned int)jobid
));
2196 if (!is_owner(server_info
, lp_const_servicename(snum
), jobid
) &&
2197 !print_access_check(server_info
, snum
, JOB_ACCESS_ADMINISTER
)) {
2198 DEBUG(3, ("resume denied by security descriptor\n"));
2199 *errcode
= WERR_ACCESS_DENIED
;
2201 /* BEGIN_ADMIN_LOG */
2202 sys_adminlog( LOG_ERR
,
2203 "Permission denied-- user not allowed to delete, \
2204 pause, or resume print job. User name: %s. Printer name: %s.",
2205 uidtoname(server_info
->utok
.uid
),
2206 lp_printername(snum
) );
2211 ret
= (*(current_printif
->job_resume
))(snum
, pjob
);
2214 *errcode
= WERR_INVALID_PARAM
;
2218 /* force update the database */
2219 print_cache_flush(lp_const_servicename(snum
));
2221 /* Send a printer notify message */
2223 notify_job_status(sharename
, jobid
, JOB_STATUS_QUEUED
);
2228 /****************************************************************************
2229 Write to a print file.
2230 ****************************************************************************/
2232 ssize_t
print_job_write(int snum
, uint32 jobid
, const char *buf
, SMB_OFF_T pos
, size_t size
)
2234 const char* sharename
= lp_const_servicename(snum
);
2235 ssize_t return_code
;
2236 struct printjob
*pjob
;
2238 pjob
= print_job_find(sharename
, jobid
);
2242 /* don't allow another process to get this info - it is meaningless */
2243 if (pjob
->pid
!= sys_getpid())
2246 return_code
= write_data_at_offset(pjob
->fd
, buf
, size
, pos
);
2248 if (return_code
>0) {
2250 pjob_store(sharename
, jobid
, pjob
);
2255 /****************************************************************************
2256 Get the queue status - do not update if db is out of date.
2257 ****************************************************************************/
2259 static int get_queue_status(const char* sharename
, print_status_struct
*status
)
2263 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
2267 ZERO_STRUCTP(status
);
2274 fstr_sprintf(keystr
, "STATUS/%s", sharename
);
2275 data
= tdb_fetch(pdb
->tdb
, string_tdb_data(keystr
));
2277 if (data
.dsize
== sizeof(print_status_struct
))
2278 /* this memcpy is ok since the status struct was
2279 not packed before storing it in the tdb */
2280 memcpy(status
, data
.dptr
, sizeof(print_status_struct
));
2281 SAFE_FREE(data
.dptr
);
2284 len
= tdb_fetch_int32(pdb
->tdb
, "INFO/total_jobs");
2285 release_print_db(pdb
);
2286 return (len
== -1 ? 0 : len
);
2289 /****************************************************************************
2290 Determine the number of jobs in a queue.
2291 ****************************************************************************/
2293 int print_queue_length(int snum
, print_status_struct
*pstatus
)
2295 const char* sharename
= lp_const_servicename( snum
);
2296 print_status_struct status
;
2299 ZERO_STRUCT( status
);
2301 /* make sure the database is up to date */
2302 if (print_cache_expired(lp_const_servicename(snum
), True
))
2303 print_queue_update(snum
, False
);
2305 /* also fetch the queue status */
2306 memset(&status
, 0, sizeof(status
));
2307 len
= get_queue_status(sharename
, &status
);
2315 /***************************************************************************
2316 Allocate a jobid. Hold the lock for as short a time as possible.
2317 ***************************************************************************/
2319 static bool allocate_print_jobid(struct tdb_print_db
*pdb
, int snum
, const char *sharename
, uint32
*pjobid
)
2324 *pjobid
= (uint32
)-1;
2326 for (i
= 0; i
< 3; i
++) {
2327 /* Lock the database - only wait 20 seconds. */
2328 if (tdb_lock_bystring_with_timeout(pdb
->tdb
, "INFO/nextjob", 20) == -1) {
2329 DEBUG(0,("allocate_print_jobid: failed to lock printing database %s\n", sharename
));
2333 if (!tdb_fetch_uint32(pdb
->tdb
, "INFO/nextjob", &jobid
)) {
2334 if (tdb_error(pdb
->tdb
) != TDB_ERR_NOEXIST
) {
2335 DEBUG(0, ("allocate_print_jobid: failed to fetch INFO/nextjob for print queue %s\n",
2337 tdb_unlock_bystring(pdb
->tdb
, "INFO/nextjob");
2340 DEBUG(10,("allocate_print_jobid: no existing jobid in %s\n", sharename
));
2344 DEBUG(10,("allocate_print_jobid: read jobid %u from %s\n", jobid
, sharename
));
2346 jobid
= NEXT_JOBID(jobid
);
2348 if (tdb_store_int32(pdb
->tdb
, "INFO/nextjob", jobid
)==-1) {
2349 DEBUG(3, ("allocate_print_jobid: failed to store INFO/nextjob.\n"));
2350 tdb_unlock_bystring(pdb
->tdb
, "INFO/nextjob");
2354 /* We've finished with the INFO/nextjob lock. */
2355 tdb_unlock_bystring(pdb
->tdb
, "INFO/nextjob");
2357 if (!print_job_exists(sharename
, jobid
)) {
2360 DEBUG(10,("allocate_print_jobid: found jobid %u in %s\n", jobid
, sharename
));
2364 DEBUG(0, ("allocate_print_jobid: failed to allocate a print job for queue %s\n",
2366 /* Probably full... */
2371 /* Store a dummy placeholder. */
2377 if (tdb_store(pdb
->tdb
, print_key(jobid
, &tmp
), dum
,
2378 TDB_INSERT
) == -1) {
2379 DEBUG(3, ("allocate_print_jobid: jobid (%d) failed to store placeholder.\n",
2389 /***************************************************************************
2390 Append a jobid to the 'jobs changed' list.
2391 ***************************************************************************/
2393 static bool add_to_jobs_changed(struct tdb_print_db
*pdb
, uint32 jobid
)
2398 SIVAL(&store_jobid
, 0, jobid
);
2399 data
.dptr
= (uint8
*)&store_jobid
;
2402 DEBUG(10,("add_to_jobs_changed: Added jobid %u\n", (unsigned int)jobid
));
2404 return (tdb_append(pdb
->tdb
, string_tdb_data("INFO/jobs_changed"),
2408 /***************************************************************************
2409 Start spooling a job - return the jobid.
2410 ***************************************************************************/
2412 uint32
print_job_start(struct auth_serversupplied_info
*server_info
, int snum
,
2413 const char *jobname
, struct spoolss_DeviceMode
*devmode
)
2417 struct printjob pjob
;
2418 const char *sharename
= lp_const_servicename(snum
);
2419 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
2427 if (!print_access_check(server_info
, snum
, PRINTER_ACCESS_USE
)) {
2428 DEBUG(3, ("print_job_start: job start denied by security descriptor\n"));
2429 release_print_db(pdb
);
2433 if (!print_time_access_check(server_info
, lp_servicename(snum
))) {
2434 DEBUG(3, ("print_job_start: job start denied by time check\n"));
2435 release_print_db(pdb
);
2439 path
= lp_pathname(snum
);
2441 /* see if we have sufficient disk space */
2442 if (lp_minprintspace(snum
)) {
2443 uint64_t dspace
, dsize
;
2444 if (sys_fsusage(path
, &dspace
, &dsize
) == 0 &&
2445 dspace
< 2*(uint64_t)lp_minprintspace(snum
)) {
2446 DEBUG(3, ("print_job_start: disk space check failed.\n"));
2447 release_print_db(pdb
);
2453 /* for autoloaded printers, check that the printcap entry still exists */
2454 if (lp_autoloaded(snum
) && !pcap_printername_ok(lp_const_servicename(snum
))) {
2455 DEBUG(3, ("print_job_start: printer name %s check failed.\n", lp_const_servicename(snum
) ));
2456 release_print_db(pdb
);
2461 /* Insure the maximum queue size is not violated */
2462 if ((njobs
= print_queue_length(snum
,NULL
)) > lp_maxprintjobs(snum
)) {
2463 DEBUG(3, ("print_job_start: Queue %s number of jobs (%d) larger than max printjobs per queue (%d).\n",
2464 sharename
, njobs
, lp_maxprintjobs(snum
) ));
2465 release_print_db(pdb
);
2470 DEBUG(10,("print_job_start: Queue %s number of jobs (%d), max printjobs = %d\n",
2471 sharename
, njobs
, lp_maxprintjobs(snum
) ));
2473 if (!allocate_print_jobid(pdb
, snum
, sharename
, &jobid
))
2476 /* create the database entry */
2480 pjob
.pid
= sys_getpid();
2483 pjob
.starttime
= time(NULL
);
2484 pjob
.status
= LPQ_SPOOLING
;
2486 pjob
.spooled
= False
;
2488 pjob
.devmode
= devmode
;
2490 fstrcpy(pjob
.jobname
, jobname
);
2492 fstrcpy(pjob
.user
, lp_printjob_username(snum
));
2493 standard_sub_advanced(sharename
, server_info
->sanitized_username
,
2494 path
, server_info
->utok
.gid
,
2495 server_info
->sanitized_username
,
2496 server_info
->info3
->base
.domain
.string
,
2497 pjob
.user
, sizeof(pjob
.user
)-1);
2498 /* ensure NULL termination */
2499 pjob
.user
[sizeof(pjob
.user
)-1] = '\0';
2501 fstrcpy(pjob
.queuename
, lp_const_servicename(snum
));
2503 /* we have a job entry - now create the spool file */
2504 slprintf(pjob
.filename
, sizeof(pjob
.filename
)-1, "%s/%s%.8u.XXXXXX",
2505 path
, PRINT_SPOOL_PREFIX
, (unsigned int)jobid
);
2506 pjob
.fd
= mkstemp(pjob
.filename
);
2508 if (pjob
.fd
== -1) {
2509 if (errno
== EACCES
) {
2510 /* Common setup error, force a report. */
2511 DEBUG(0, ("print_job_start: insufficient permissions \
2512 to open spool file %s.\n", pjob
.filename
));
2514 /* Normal case, report at level 3 and above. */
2515 DEBUG(3, ("print_job_start: can't open spool file %s,\n", pjob
.filename
));
2516 DEBUGADD(3, ("errno = %d (%s).\n", errno
, strerror(errno
)));
2521 pjob_store(sharename
, jobid
, &pjob
);
2523 /* Update the 'jobs changed' entry used by print_queue_status. */
2524 add_to_jobs_changed(pdb
, jobid
);
2526 /* Ensure we keep a rough count of the number of total jobs... */
2527 tdb_change_int32_atomic(pdb
->tdb
, "INFO/total_jobs", &njobs
, 1);
2529 release_print_db(pdb
);
2535 pjob_delete(sharename
, jobid
);
2537 release_print_db(pdb
);
2539 DEBUG(3, ("print_job_start: returning fail. Error = %s\n", strerror(errno
) ));
2543 /****************************************************************************
2544 Update the number of pages spooled to jobid
2545 ****************************************************************************/
2547 void print_job_endpage(int snum
, uint32 jobid
)
2549 const char* sharename
= lp_const_servicename(snum
);
2550 struct printjob
*pjob
;
2552 pjob
= print_job_find(sharename
, jobid
);
2555 /* don't allow another process to get this info - it is meaningless */
2556 if (pjob
->pid
!= sys_getpid())
2560 pjob_store(sharename
, jobid
, pjob
);
2563 /****************************************************************************
2564 Print a file - called on closing the file. This spools the job.
2565 If normal close is false then we're tearing down the jobs - treat as an
2567 ****************************************************************************/
2569 bool print_job_end(int snum
, uint32 jobid
, enum file_close_type close_type
)
2571 const char* sharename
= lp_const_servicename(snum
);
2572 struct printjob
*pjob
;
2574 SMB_STRUCT_STAT sbuf
;
2575 struct printif
*current_printif
= get_printer_fns( snum
);
2577 pjob
= print_job_find(sharename
, jobid
);
2582 if (pjob
->spooled
|| pjob
->pid
!= sys_getpid())
2585 if ((close_type
== NORMAL_CLOSE
|| close_type
== SHUTDOWN_CLOSE
) &&
2586 (sys_fstat(pjob
->fd
, &sbuf
, false) == 0)) {
2587 pjob
->size
= sbuf
.st_ex_size
;
2593 * Not a normal close or we couldn't stat the job file,
2594 * so something has gone wrong. Cleanup.
2598 DEBUG(3,("print_job_end: failed to stat file for jobid %d\n", jobid
));
2602 /* Technically, this is not quite right. If the printer has a separator
2603 * page turned on, the NT spooler prints the separator page even if the
2604 * print job is 0 bytes. 010215 JRR */
2605 if (pjob
->size
== 0 || pjob
->status
== LPQ_DELETING
) {
2606 /* don't bother spooling empty files or something being deleted. */
2607 DEBUG(5,("print_job_end: canceling spool of %s (%s)\n",
2608 pjob
->filename
, pjob
->size
? "deleted" : "zero length" ));
2609 unlink(pjob
->filename
);
2610 pjob_delete(sharename
, jobid
);
2614 ret
= (*(current_printif
->job_submit
))(snum
, pjob
);
2619 /* The print job has been successfully handed over to the back-end */
2621 pjob
->spooled
= True
;
2622 pjob
->status
= LPQ_QUEUED
;
2623 pjob_store(sharename
, jobid
, pjob
);
2625 /* make sure the database is up to date */
2626 if (print_cache_expired(lp_const_servicename(snum
), True
))
2627 print_queue_update(snum
, False
);
2633 /* The print job was not successfully started. Cleanup */
2634 /* Still need to add proper error return propagation! 010122:JRR */
2635 unlink(pjob
->filename
);
2636 pjob_delete(sharename
, jobid
);
2640 /****************************************************************************
2641 Get a snapshot of jobs in the system without traversing.
2642 ****************************************************************************/
2644 static bool get_stored_queue_info(struct tdb_print_db
*pdb
, int snum
, int *pcount
, print_queue_struct
**ppqueue
)
2646 TDB_DATA data
, cgdata
;
2647 print_queue_struct
*queue
= NULL
;
2649 uint32 extra_count
= 0;
2650 int total_count
= 0;
2653 int max_reported_jobs
= lp_max_reported_jobs(snum
);
2655 const char* sharename
= lp_servicename(snum
);
2657 /* make sure the database is up to date */
2658 if (print_cache_expired(lp_const_servicename(snum
), True
))
2659 print_queue_update(snum
, False
);
2665 ZERO_STRUCT(cgdata
);
2667 /* Get the stored queue data. */
2668 data
= tdb_fetch(pdb
->tdb
, string_tdb_data("INFO/linear_queue_array"));
2670 if (data
.dptr
&& data
.dsize
>= sizeof(qcount
))
2671 len
+= tdb_unpack(data
.dptr
+ len
, data
.dsize
- len
, "d", &qcount
);
2673 /* Get the changed jobs list. */
2674 cgdata
= tdb_fetch(pdb
->tdb
, string_tdb_data("INFO/jobs_changed"));
2675 if (cgdata
.dptr
!= NULL
&& (cgdata
.dsize
% 4 == 0))
2676 extra_count
= cgdata
.dsize
/4;
2678 DEBUG(5,("get_stored_queue_info: qcount = %u, extra_count = %u\n", (unsigned int)qcount
, (unsigned int)extra_count
));
2680 /* Allocate the queue size. */
2681 if (qcount
== 0 && extra_count
== 0)
2684 if ((queue
= SMB_MALLOC_ARRAY(print_queue_struct
, qcount
+ extra_count
)) == NULL
)
2687 /* Retrieve the linearised queue data. */
2689 for( i
= 0; i
< qcount
; i
++) {
2690 uint32 qjob
, qsize
, qpage_count
, qstatus
, qpriority
, qtime
;
2691 len
+= tdb_unpack(data
.dptr
+ len
, data
.dsize
- len
, "ddddddff",
2700 queue
[i
].job
= qjob
;
2701 queue
[i
].size
= qsize
;
2702 queue
[i
].page_count
= qpage_count
;
2703 queue
[i
].status
= qstatus
;
2704 queue
[i
].priority
= qpriority
;
2705 queue
[i
].time
= qtime
;
2708 total_count
= qcount
;
2710 /* Add in the changed jobids. */
2711 for( i
= 0; i
< extra_count
; i
++) {
2713 struct printjob
*pjob
;
2715 jobid
= IVAL(cgdata
.dptr
, i
*4);
2716 DEBUG(5,("get_stored_queue_info: changed job = %u\n", (unsigned int)jobid
));
2717 pjob
= print_job_find(lp_const_servicename(snum
), jobid
);
2719 DEBUG(5,("get_stored_queue_info: failed to find changed job = %u\n", (unsigned int)jobid
));
2720 remove_from_jobs_changed(sharename
, jobid
);
2724 queue
[total_count
].job
= jobid
;
2725 queue
[total_count
].size
= pjob
->size
;
2726 queue
[total_count
].page_count
= pjob
->page_count
;
2727 queue
[total_count
].status
= pjob
->status
;
2728 queue
[total_count
].priority
= 1;
2729 queue
[total_count
].time
= pjob
->starttime
;
2730 fstrcpy(queue
[total_count
].fs_user
, pjob
->user
);
2731 fstrcpy(queue
[total_count
].fs_file
, pjob
->jobname
);
2735 /* Sort the queue by submission time otherwise they are displayed
2738 TYPESAFE_QSORT(queue
, total_count
, printjob_comp
);
2740 DEBUG(5,("get_stored_queue_info: total_count = %u\n", (unsigned int)total_count
));
2742 if (max_reported_jobs
&& total_count
> max_reported_jobs
)
2743 total_count
= max_reported_jobs
;
2746 *pcount
= total_count
;
2752 SAFE_FREE(data
.dptr
);
2753 SAFE_FREE(cgdata
.dptr
);
2757 /****************************************************************************
2758 Get a printer queue listing.
2759 set queue = NULL and status = NULL if you just want to update the cache
2760 ****************************************************************************/
2762 int print_queue_status(int snum
,
2763 print_queue_struct
**ppqueue
,
2764 print_status_struct
*status
)
2768 const char *sharename
;
2769 struct tdb_print_db
*pdb
;
2772 /* make sure the database is up to date */
2774 if (print_cache_expired(lp_const_servicename(snum
), True
))
2775 print_queue_update(snum
, False
);
2777 /* return if we are done */
2778 if ( !ppqueue
|| !status
)
2782 sharename
= lp_const_servicename(snum
);
2783 pdb
= get_print_db_byname(sharename
);
2789 * Fetch the queue status. We must do this first, as there may
2790 * be no jobs in the queue.
2793 ZERO_STRUCTP(status
);
2794 slprintf(keystr
, sizeof(keystr
)-1, "STATUS/%s", sharename
);
2795 key
= string_tdb_data(keystr
);
2797 data
= tdb_fetch(pdb
->tdb
, key
);
2799 if (data
.dsize
== sizeof(*status
)) {
2800 /* this memcpy is ok since the status struct was
2801 not packed before storing it in the tdb */
2802 memcpy(status
, data
.dptr
, sizeof(*status
));
2804 SAFE_FREE(data
.dptr
);
2808 * Now, fetch the print queue information. We first count the number
2809 * of entries, and then only retrieve the queue if necessary.
2812 if (!get_stored_queue_info(pdb
, snum
, &count
, ppqueue
)) {
2813 release_print_db(pdb
);
2817 release_print_db(pdb
);
2821 /****************************************************************************
2823 ****************************************************************************/
2825 WERROR
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 return WERR_ACCESS_DENIED
;
2838 ret
= (*(current_printif
->queue_pause
))(snum
);
2843 return WERR_INVALID_PARAM
;
2846 /* force update the database */
2847 print_cache_flush(lp_const_servicename(snum
));
2849 /* Send a printer notify message */
2851 notify_printer_status(snum
, PRINTER_STATUS_PAUSED
);
2856 /****************************************************************************
2858 ****************************************************************************/
2860 WERROR
print_queue_resume(struct auth_serversupplied_info
*server_info
, int snum
)
2863 struct printif
*current_printif
= get_printer_fns( snum
);
2865 if (!print_access_check(server_info
, snum
,
2866 PRINTER_ACCESS_ADMINISTER
)) {
2867 return WERR_ACCESS_DENIED
;
2872 ret
= (*(current_printif
->queue_resume
))(snum
);
2877 return WERR_INVALID_PARAM
;
2880 /* make sure the database is up to date */
2881 if (print_cache_expired(lp_const_servicename(snum
), True
))
2882 print_queue_update(snum
, True
);
2884 /* Send a printer notify message */
2886 notify_printer_status(snum
, PRINTER_STATUS_OK
);
2891 /****************************************************************************
2892 Purge a queue - implemented by deleting all jobs that we can delete.
2893 ****************************************************************************/
2895 WERROR
print_queue_purge(struct auth_serversupplied_info
*server_info
, int snum
)
2897 print_queue_struct
*queue
;
2898 print_status_struct status
;
2902 /* Force and update so the count is accurate (i.e. not a cached count) */
2903 print_queue_update(snum
, True
);
2905 can_job_admin
= print_access_check(server_info
, snum
,
2906 JOB_ACCESS_ADMINISTER
);
2907 njobs
= print_queue_status(snum
, &queue
, &status
);
2909 if ( can_job_admin
)
2912 for (i
=0;i
<njobs
;i
++) {
2913 bool owner
= is_owner(server_info
, lp_const_servicename(snum
),
2916 if (owner
|| can_job_admin
) {
2917 print_job_delete1(snum
, queue
[i
].job
);
2921 if ( can_job_admin
)
2924 /* update the cache */
2925 print_queue_update( snum
, True
);