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 2 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, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 extern SIG_ATOMIC_T got_sig_term
;
27 extern SIG_ATOMIC_T reload_after_sighup
;
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
= (char*)&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
);
94 data
.dptr
= (char*)buf
;
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
);
115 key
.dptr
= (char*)buf
;
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 fstrcpy( sharename
, jinfo
->sharename
);
122 *pjobid
= jinfo
->jobid
;
123 DEBUG(10,("rap_to_pjobid: jobid %u maps to RAP jobid %u\n",
124 (unsigned int)*pjobid
, (unsigned int)rap_jobid
));
125 SAFE_FREE(data
.dptr
);
129 DEBUG(10,("rap_to_pjobid: Failed to lookup RAP jobid %u\n",
130 (unsigned int)rap_jobid
));
131 SAFE_FREE(data
.dptr
);
135 static void rap_jobid_delete(const char* sharename
, uint32 jobid
)
139 struct rap_jobid_key jinfo
;
142 DEBUG(10,("rap_jobid_delete: called.\n"));
147 ZERO_STRUCT( jinfo
);
148 fstrcpy( jinfo
.sharename
, sharename
);
150 key
.dptr
= (char*)&jinfo
;
151 key
.dsize
= sizeof(jinfo
);
153 data
= tdb_fetch(rap_tdb
, key
);
154 if (!data
.dptr
|| (data
.dsize
!= sizeof(uint16
))) {
155 DEBUG(10,("rap_jobid_delete: cannot find jobid %u\n",
156 (unsigned int)jobid
));
157 SAFE_FREE(data
.dptr
);
161 DEBUG(10,("rap_jobid_delete: deleting jobid %u\n",
162 (unsigned int)jobid
));
164 rap_jobid
= SVAL(data
.dptr
, 0);
165 SAFE_FREE(data
.dptr
);
166 SSVAL(buf
,0,rap_jobid
);
167 data
.dptr
= (char*)buf
;
168 data
.dsize
= sizeof(rap_jobid
);
169 tdb_delete(rap_tdb
, key
);
170 tdb_delete(rap_tdb
, data
);
173 static int get_queue_status(const char* sharename
, print_status_struct
*);
175 /****************************************************************************
176 Initialise the printing backend. Called once at startup before the fork().
177 ****************************************************************************/
179 BOOL
print_backend_init(void)
181 const char *sversion
= "INFO/version";
182 pstring printing_path
;
183 int services
= lp_numservices();
186 unlink(lock_path("printing.tdb"));
187 pstrcpy(printing_path
,lock_path("printing"));
188 mkdir(printing_path
,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_traverse(pdb
->tdb
, tdb_traverse_delete_fn
, NULL
);
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();
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
)
274 ret
.dptr
= (void *)&j
;
275 ret
.dsize
= sizeof(j
);
279 /***********************************************************************
280 unpack a pjob from a tdb buffer
281 ***********************************************************************/
283 int unpack_pjob( char* buf
, int buflen
, struct printjob
*pjob
)
287 uint32 pjpid
, pjsysjob
, pjfd
, pjstarttime
, pjstatus
;
288 uint32 pjsize
, pjpage_count
, pjspooled
, pjsmbjob
;
293 len
+= tdb_unpack(buf
+len
, buflen
-len
, "dddddddddffff",
311 if ( (used
= unpack_devicemode(&pjob
->nt_devmode
, buf
+len
, buflen
-len
)) == -1 )
317 pjob
->sysjob
= pjsysjob
;
319 pjob
->starttime
= pjstarttime
;
320 pjob
->status
= pjstatus
;
322 pjob
->page_count
= pjpage_count
;
323 pjob
->spooled
= pjspooled
;
324 pjob
->smbjob
= pjsmbjob
;
330 /****************************************************************************
331 Useful function to find a print job in the database.
332 ****************************************************************************/
334 static struct printjob
*print_job_find(const char *sharename
, uint32 jobid
)
336 static struct printjob pjob
;
338 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
340 DEBUG(10,("print_job_find: looking up job %u for share %s\n",
341 (unsigned int)jobid
, sharename
));
347 ret
= tdb_fetch(pdb
->tdb
, print_key(jobid
));
348 release_print_db(pdb
);
351 DEBUG(10,("print_job_find: failed to find jobid %u.\n", (unsigned int)jobid
));
355 if ( pjob
.nt_devmode
) {
356 free_nt_devicemode( &pjob
.nt_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 static uint32 sysjob_to_jobid_value
;
379 static int unixjob_traverse_fn(TDB_CONTEXT
*the_tdb
, TDB_DATA key
,
380 TDB_DATA data
, void *state
)
382 struct printjob
*pjob
;
383 int *sysjob
= (int *)state
;
385 if (!data
.dptr
|| data
.dsize
== 0)
388 pjob
= (struct printjob
*)data
.dptr
;
389 if (key
.dsize
!= sizeof(uint32
))
392 if (*sysjob
== pjob
->sysjob
) {
393 uint32 jobid
= IVAL(key
.dptr
,0);
395 sysjob_to_jobid_value
= jobid
;
402 /****************************************************************************
403 This is a *horribly expensive call as we have to iterate through all the
404 current printer tdb's. Don't do this often ! JRA.
405 ****************************************************************************/
407 uint32
sysjob_to_jobid(int unix_jobid
)
409 int services
= lp_numservices();
412 sysjob_to_jobid_value
= (uint32
)-1;
414 for (snum
= 0; snum
< services
; snum
++) {
415 struct tdb_print_db
*pdb
;
416 if (!lp_print_ok(snum
))
418 pdb
= get_print_db_byname(lp_const_servicename(snum
));
422 tdb_traverse(pdb
->tdb
, unixjob_traverse_fn
, &unix_jobid
);
423 release_print_db(pdb
);
424 if (sysjob_to_jobid_value
!= (uint32
)-1)
425 return sysjob_to_jobid_value
;
430 /****************************************************************************
431 Send notifications based on what has changed after a pjob_store.
432 ****************************************************************************/
436 uint32 spoolss_status
;
437 } lpq_to_spoolss_status_map
[] = {
438 { LPQ_QUEUED
, JOB_STATUS_QUEUED
},
439 { LPQ_PAUSED
, JOB_STATUS_PAUSED
},
440 { LPQ_SPOOLING
, JOB_STATUS_SPOOLING
},
441 { LPQ_PRINTING
, JOB_STATUS_PRINTING
},
442 { LPQ_DELETING
, JOB_STATUS_DELETING
},
443 { LPQ_OFFLINE
, JOB_STATUS_OFFLINE
},
444 { LPQ_PAPEROUT
, JOB_STATUS_PAPEROUT
},
445 { LPQ_PRINTED
, JOB_STATUS_PRINTED
},
446 { LPQ_DELETED
, JOB_STATUS_DELETED
},
447 { LPQ_BLOCKED
, JOB_STATUS_BLOCKED
},
448 { LPQ_USER_INTERVENTION
, JOB_STATUS_USER_INTERVENTION
},
452 /* Convert a lpq status value stored in printing.tdb into the
453 appropriate win32 API constant. */
455 static uint32
map_to_spoolss_status(uint32 lpq_status
)
459 while (lpq_to_spoolss_status_map
[i
].lpq_status
!= -1) {
460 if (lpq_to_spoolss_status_map
[i
].lpq_status
== lpq_status
)
461 return lpq_to_spoolss_status_map
[i
].spoolss_status
;
468 static void pjob_store_notify(const char* sharename
, uint32 jobid
, struct printjob
*old_data
,
469 struct printjob
*new_data
)
471 BOOL new_job
= False
;
476 /* Job attributes that can't be changed. We only send
477 notification for these on a new job. */
479 /* ACHTUNG! Due to a bug in Samba's spoolss parsing of the
480 NOTIFY_INFO_DATA buffer, we *have* to send the job submission
481 time first or else we'll end up with potential alignment
482 errors. I don't think the systemtime should be spooled as
483 a string, but this gets us around that error.
484 --jerry (i'll feel dirty for this) */
487 notify_job_submitted(sharename
, jobid
, new_data
->starttime
);
488 notify_job_username(sharename
, jobid
, new_data
->user
);
491 if (new_job
|| !strequal(old_data
->jobname
, new_data
->jobname
))
492 notify_job_name(sharename
, jobid
, new_data
->jobname
);
494 /* Job attributes of a new job or attributes that can be
497 if (new_job
|| !strequal(old_data
->jobname
, new_data
->jobname
))
498 notify_job_name(sharename
, jobid
, new_data
->jobname
);
500 if (new_job
|| old_data
->status
!= new_data
->status
)
501 notify_job_status(sharename
, jobid
, map_to_spoolss_status(new_data
->status
));
503 if (new_job
|| old_data
->size
!= new_data
->size
)
504 notify_job_total_bytes(sharename
, jobid
, new_data
->size
);
506 if (new_job
|| old_data
->page_count
!= new_data
->page_count
)
507 notify_job_total_pages(sharename
, jobid
, new_data
->page_count
);
510 /****************************************************************************
511 Store a job structure back to the database.
512 ****************************************************************************/
514 static BOOL
pjob_store(const char* sharename
, uint32 jobid
, struct printjob
*pjob
)
516 TDB_DATA old_data
, new_data
;
518 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
520 int len
, newlen
, buflen
;
528 old_data
= tdb_fetch(pdb
->tdb
, print_key(jobid
));
530 /* Doh! Now we have to pack/unpack data since the NT_DEVICEMODE was added */
537 len
+= tdb_pack(buf
+len
, buflen
-len
, "dddddddddffff",
539 (uint32
)pjob
->sysjob
,
541 (uint32
)pjob
->starttime
,
542 (uint32
)pjob
->status
,
544 (uint32
)pjob
->page_count
,
545 (uint32
)pjob
->spooled
,
546 (uint32
)pjob
->smbjob
,
552 len
+= pack_devicemode(pjob
->nt_devmode
, buf
+len
, buflen
-len
);
555 buf
= (char *)SMB_REALLOC(buf
, len
);
557 DEBUG(0,("pjob_store: failed to enlarge buffer!\n"));
562 } while ( buflen
!= len
);
568 new_data
.dsize
= len
;
569 ret
= (tdb_store(pdb
->tdb
, print_key(jobid
), new_data
, TDB_REPLACE
) == 0);
571 release_print_db(pdb
);
573 /* Send notify updates for what has changed */
576 struct printjob old_pjob
;
578 if ( old_data
.dsize
)
580 if ( unpack_pjob( old_data
.dptr
, old_data
.dsize
, &old_pjob
) != -1 )
582 pjob_store_notify( sharename
, jobid
, &old_pjob
, pjob
);
583 free_nt_devicemode( &old_pjob
.nt_devmode
);
588 pjob_store_notify( sharename
, jobid
, NULL
, pjob
);
593 SAFE_FREE( old_data
.dptr
);
599 /****************************************************************************
600 Remove a job structure from the database.
601 ****************************************************************************/
603 void pjob_delete(const char* sharename
, uint32 jobid
)
605 struct printjob
*pjob
;
606 uint32 job_status
= 0;
607 struct tdb_print_db
*pdb
;
609 pdb
= get_print_db_byname( sharename
);
614 pjob
= print_job_find( sharename
, jobid
);
617 DEBUG(5, ("pjob_delete: we were asked to delete nonexistent job %u\n",
618 (unsigned int)jobid
));
619 release_print_db(pdb
);
623 /* We must cycle through JOB_STATUS_DELETING and
624 JOB_STATUS_DELETED for the port monitor to delete the job
627 job_status
= JOB_STATUS_DELETING
|JOB_STATUS_DELETED
;
628 notify_job_status(sharename
, jobid
, job_status
);
630 /* Remove from printing.tdb */
632 tdb_delete(pdb
->tdb
, print_key(jobid
));
633 remove_from_jobs_changed(sharename
, jobid
);
634 release_print_db( pdb
);
635 rap_jobid_delete(sharename
, jobid
);
638 /****************************************************************************
639 Parse a file name from the system spooler to generate a jobid.
640 ****************************************************************************/
642 static uint32
print_parse_jobid(char *fname
)
646 if (strncmp(fname
,PRINT_SPOOL_PREFIX
,strlen(PRINT_SPOOL_PREFIX
)) != 0)
648 fname
+= strlen(PRINT_SPOOL_PREFIX
);
654 return (uint32
)jobid
;
657 /****************************************************************************
658 List a unix job in the print database.
659 ****************************************************************************/
661 static void print_unix_job(const char *sharename
, print_queue_struct
*q
, uint32 jobid
)
663 struct printjob pj
, *old_pj
;
665 if (jobid
== (uint32
)-1)
666 jobid
= q
->job
+ UNIX_JOB_START
;
668 /* Preserve the timestamp on an existing unix print job */
670 old_pj
= print_job_find(sharename
, jobid
);
677 pj
.starttime
= old_pj
? old_pj
->starttime
: q
->time
;
678 pj
.status
= q
->status
;
681 fstrcpy(pj
.filename
, old_pj
? old_pj
->filename
: "");
682 if (jobid
< UNIX_JOB_START
) {
684 fstrcpy(pj
.jobname
, old_pj
? old_pj
->jobname
: "Remote Downlevel Document");
687 fstrcpy(pj
.jobname
, old_pj
? old_pj
->jobname
: q
->fs_file
);
689 fstrcpy(pj
.user
, old_pj
? old_pj
->user
: q
->fs_user
);
690 fstrcpy(pj
.queuename
, old_pj
? old_pj
->queuename
: sharename
);
692 pjob_store(sharename
, jobid
, &pj
);
696 struct traverse_struct
{
697 print_queue_struct
*queue
;
698 int qcount
, snum
, maxcount
, total_jobs
;
699 const char *sharename
;
701 const char *lprm_command
;
702 struct printif
*print_if
;
705 /****************************************************************************
706 Utility fn to delete any jobs that are no longer active.
707 ****************************************************************************/
709 static int traverse_fn_delete(TDB_CONTEXT
*t
, TDB_DATA key
, TDB_DATA data
, void *state
)
711 struct traverse_struct
*ts
= (struct traverse_struct
*)state
;
712 struct printjob pjob
;
716 if ( key
.dsize
!= sizeof(jobid
) )
719 jobid
= IVAL(key
.dptr
, 0);
720 if ( unpack_pjob( data
.dptr
, data
.dsize
, &pjob
) == -1 )
722 free_nt_devicemode( &pjob
.nt_devmode
);
726 /* remove a unix job if it isn't in the system queue any more */
728 for (i
=0;i
<ts
->qcount
;i
++) {
729 uint32 u_jobid
= (ts
->queue
[i
].job
+ UNIX_JOB_START
);
730 if (jobid
== u_jobid
)
733 if (i
== ts
->qcount
) {
734 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !smbjob\n",
735 (unsigned int)jobid
));
736 pjob_delete(ts
->sharename
, jobid
);
740 /* need to continue the the bottom of the function to
741 save the correct attributes */
744 /* maybe it hasn't been spooled yet */
746 /* if a job is not spooled and the process doesn't
747 exist then kill it. This cleans up after smbd
749 if (!process_exists_by_pid(pjob
.pid
)) {
750 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !process_exists (%u)\n",
751 (unsigned int)jobid
, (unsigned int)pjob
.pid
));
752 pjob_delete(ts
->sharename
, jobid
);
758 /* this check only makes sense for jobs submitted from Windows clients */
761 for (i
=0;i
<ts
->qcount
;i
++) {
764 if ( pjob
.status
== LPQ_DELETED
)
767 curr_jobid
= print_parse_jobid(ts
->queue
[i
].fs_file
);
769 if (jobid
== curr_jobid
) {
771 /* try to clean up any jobs that need to be deleted */
773 if ( pjob
.status
== LPQ_DELETING
) {
776 result
= (*(ts
->print_if
->job_delete
))(
777 ts
->sharename
, ts
->lprm_command
, &pjob
);
780 /* if we can't delete, then reset the job status */
781 pjob
.status
= LPQ_QUEUED
;
782 pjob_store(ts
->sharename
, jobid
, &pjob
);
785 /* if we deleted the job, the remove the tdb record */
786 pjob_delete(ts
->sharename
, jobid
);
787 pjob
.status
= LPQ_DELETED
;
797 /* The job isn't in the system queue - we have to assume it has
798 completed, so delete the database entry. */
800 if (i
== ts
->qcount
) {
802 /* A race can occur between the time a job is spooled and
803 when it appears in the lpq output. This happens when
804 the job is added to printing.tdb when another smbd
805 running print_queue_update() has completed a lpq and
806 is currently traversing the printing tdb and deleting jobs.
807 Don't delete the job if it was submitted after the lpq_time. */
809 if (pjob
.starttime
< ts
->lpq_time
) {
810 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to pjob.starttime (%u) < ts->lpq_time (%u)\n",
812 (unsigned int)pjob
.starttime
,
813 (unsigned int)ts
->lpq_time
));
814 pjob_delete(ts
->sharename
, jobid
);
820 /* Save the pjob attributes we will store.
821 FIXME!!! This is the only place where queue->job
822 represents the SMB jobid --jerry */
824 ts
->queue
[i
].job
= jobid
;
825 ts
->queue
[i
].size
= pjob
.size
;
826 ts
->queue
[i
].page_count
= pjob
.page_count
;
827 ts
->queue
[i
].status
= pjob
.status
;
828 ts
->queue
[i
].priority
= 1;
829 ts
->queue
[i
].time
= pjob
.starttime
;
830 fstrcpy(ts
->queue
[i
].fs_user
, pjob
.user
);
831 fstrcpy(ts
->queue
[i
].fs_file
, pjob
.jobname
);
838 /****************************************************************************
839 Check if the print queue has been updated recently enough.
840 ****************************************************************************/
842 static void print_cache_flush(int snum
)
845 const char *sharename
= lp_const_servicename(snum
);
846 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
850 slprintf(key
, sizeof(key
)-1, "CACHE/%s", sharename
);
851 tdb_store_int32(pdb
->tdb
, key
, -1);
852 release_print_db(pdb
);
855 /****************************************************************************
856 Check if someone already thinks they are doing the update.
857 ****************************************************************************/
859 static pid_t
get_updating_pid(const char *sharename
)
864 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
868 slprintf(keystr
, sizeof(keystr
)-1, "UPDATING/%s", sharename
);
870 key
.dsize
= strlen(keystr
);
872 data
= tdb_fetch(pdb
->tdb
, key
);
873 release_print_db(pdb
);
874 if (!data
.dptr
|| data
.dsize
!= sizeof(pid_t
)) {
875 SAFE_FREE(data
.dptr
);
879 updating_pid
= IVAL(data
.dptr
, 0);
880 SAFE_FREE(data
.dptr
);
882 if (process_exists_by_pid(updating_pid
))
888 /****************************************************************************
889 Set the fact that we're doing the update, or have finished doing the update
891 ****************************************************************************/
893 static void set_updating_pid(const fstring sharename
, BOOL updating
)
898 pid_t updating_pid
= sys_getpid();
901 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
906 slprintf(keystr
, sizeof(keystr
)-1, "UPDATING/%s", sharename
);
908 key
.dsize
= strlen(keystr
);
910 DEBUG(5, ("set_updating_pid: %s updating lpq cache for print share %s\n",
911 updating
? "" : "not ",
915 tdb_delete(pdb
->tdb
, key
);
916 release_print_db(pdb
);
920 SIVAL( buffer
, 0, updating_pid
);
921 data
.dptr
= (void *)buffer
;
922 data
.dsize
= 4; /* we always assume this is a 4 byte value */
924 tdb_store(pdb
->tdb
, key
, data
, TDB_REPLACE
);
925 release_print_db(pdb
);
928 /****************************************************************************
929 Sort print jobs by submittal time.
930 ****************************************************************************/
932 static int printjob_comp(print_queue_struct
*j1
, print_queue_struct
*j2
)
943 /* Sort on job start time */
945 if (j1
->time
== j2
->time
)
947 return (j1
->time
> j2
->time
) ? 1 : -1;
950 /****************************************************************************
951 Store the sorted queue representation for later portmon retrieval.
953 ****************************************************************************/
955 static void store_queue_struct(struct tdb_print_db
*pdb
, struct traverse_struct
*pts
)
958 int max_reported_jobs
= lp_max_reported_jobs(pts
->snum
);
959 print_queue_struct
*queue
= pts
->queue
;
964 if (max_reported_jobs
&& (max_reported_jobs
< pts
->qcount
))
965 pts
->qcount
= max_reported_jobs
;
968 /* Work out the size. */
970 data
.dsize
+= tdb_pack(NULL
, 0, "d", qcount
);
972 for (i
= 0; i
< pts
->qcount
; i
++) {
973 if ( queue
[i
].status
== LPQ_DELETED
)
977 data
.dsize
+= tdb_pack(NULL
, 0, "ddddddff",
978 (uint32
)queue
[i
].job
,
979 (uint32
)queue
[i
].size
,
980 (uint32
)queue
[i
].page_count
,
981 (uint32
)queue
[i
].status
,
982 (uint32
)queue
[i
].priority
,
983 (uint32
)queue
[i
].time
,
988 if ((data
.dptr
= SMB_MALLOC(data
.dsize
)) == NULL
)
992 len
+= tdb_pack(data
.dptr
+ len
, data
.dsize
- len
, "d", qcount
);
993 for (i
= 0; i
< pts
->qcount
; i
++) {
994 if ( queue
[i
].status
== LPQ_DELETED
)
997 len
+= tdb_pack(data
.dptr
+ len
, data
.dsize
- len
, "ddddddff",
998 (uint32
)queue
[i
].job
,
999 (uint32
)queue
[i
].size
,
1000 (uint32
)queue
[i
].page_count
,
1001 (uint32
)queue
[i
].status
,
1002 (uint32
)queue
[i
].priority
,
1003 (uint32
)queue
[i
].time
,
1008 tdb_store(pdb
->tdb
, string_tdb_data("INFO/linear_queue_array"), data
,
1010 SAFE_FREE(data
.dptr
);
1014 static TDB_DATA
get_jobs_changed_data(struct tdb_print_db
*pdb
)
1020 data
= tdb_fetch(pdb
->tdb
, string_tdb_data("INFO/jobs_changed"));
1021 if (data
.dptr
== NULL
|| data
.dsize
== 0 || (data
.dsize
% 4 != 0)) {
1022 SAFE_FREE(data
.dptr
);
1029 static void check_job_changed(const char *sharename
, TDB_DATA data
, uint32 jobid
)
1032 unsigned int job_count
= data
.dsize
/ 4;
1034 for (i
= 0; i
< job_count
; i
++) {
1037 ch_jobid
= IVAL(data
.dptr
, i
*4);
1038 if (ch_jobid
== jobid
)
1039 remove_from_jobs_changed(sharename
, jobid
);
1043 /****************************************************************************
1044 Check if the print queue has been updated recently enough.
1045 ****************************************************************************/
1047 static BOOL
print_cache_expired(const char *sharename
, BOOL check_pending
)
1050 time_t last_qscan_time
, time_now
= time(NULL
);
1051 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1052 BOOL result
= False
;
1057 snprintf(key
, sizeof(key
), "CACHE/%s", sharename
);
1058 last_qscan_time
= (time_t)tdb_fetch_int32(pdb
->tdb
, key
);
1061 * Invalidate the queue for 3 reasons.
1062 * (1). last queue scan time == -1.
1063 * (2). Current time - last queue scan time > allowed cache time.
1064 * (3). last queue scan time > current time + MAX_CACHE_VALID_TIME (1 hour by default).
1065 * This last test picks up machines for which the clock has been moved
1066 * forward, an lpq scan done and then the clock moved back. Otherwise
1067 * that last lpq scan would stay around for a loooong loooong time... :-). JRA.
1070 if (last_qscan_time
== ((time_t)-1)
1071 || (time_now
- last_qscan_time
) >= lp_lpqcachetime()
1072 || last_qscan_time
> (time_now
+ MAX_CACHE_VALID_TIME
))
1075 time_t msg_pending_time
;
1077 DEBUG(4, ("print_cache_expired: cache expired for queue %s "
1078 "(last_qscan_time = %d, time now = %d, qcachetime = %d)\n",
1079 sharename
, (int)last_qscan_time
, (int)time_now
,
1080 (int)lp_lpqcachetime() ));
1082 /* check if another smbd has already sent a message to update the
1083 queue. Give the pending message one minute to clear and
1084 then send another message anyways. Make sure to check for
1085 clocks that have been run forward and then back again. */
1087 snprintf(key
, sizeof(key
), "MSG_PENDING/%s", sharename
);
1090 && tdb_fetch_uint32( pdb
->tdb
, key
, &u
)
1091 && (msg_pending_time
=u
) > 0
1092 && msg_pending_time
<= time_now
1093 && (time_now
- msg_pending_time
) < 60 )
1095 DEBUG(4,("print_cache_expired: message already pending for %s. Accepting cache\n",
1104 release_print_db(pdb
);
1108 /****************************************************************************
1109 main work for updating the lpq cahe for a printer queue
1110 ****************************************************************************/
1112 static void print_queue_update_internal( const char *sharename
,
1113 struct printif
*current_printif
,
1114 char *lpq_command
, char *lprm_command
)
1117 print_queue_struct
*queue
= NULL
;
1118 print_status_struct status
;
1119 print_status_struct old_status
;
1120 struct printjob
*pjob
;
1121 struct traverse_struct tstruct
;
1124 fstring keystr
, cachestr
;
1125 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1131 DEBUG(5,("print_queue_update_internal: printer = %s, type = %d, lpq command = [%s]\n",
1132 sharename
, current_printif
->type
, lpq_command
));
1135 * Update the cache time FIRST ! Stops others even
1136 * attempting to get the lock and doing this
1137 * if the lpq takes a long time.
1140 slprintf(cachestr
, sizeof(cachestr
)-1, "CACHE/%s", sharename
);
1141 tdb_store_int32(pdb
->tdb
, cachestr
, (int)time(NULL
));
1143 /* get the current queue using the appropriate interface */
1144 ZERO_STRUCT(status
);
1146 qcount
= (*(current_printif
->queue_get
))(sharename
,
1147 current_printif
->type
,
1148 lpq_command
, &queue
, &status
);
1150 DEBUG(3, ("print_queue_update_internal: %d job%s in queue for %s\n",
1151 qcount
, (qcount
!= 1) ? "s" : "", sharename
));
1153 /* Sort the queue by submission time otherwise they are displayed
1156 qsort(queue
, qcount
, sizeof(print_queue_struct
),
1157 QSORT_CAST(printjob_comp
));
1160 any job in the internal database that is marked as spooled
1161 and doesn't exist in the system queue is considered finished
1162 and removed from the database
1164 any job in the system database but not in the internal database
1165 is added as a unix job
1167 fill in any system job numbers as we go
1170 jcdata
= get_jobs_changed_data(pdb
);
1172 for (i
=0; i
<qcount
; i
++) {
1173 uint32 jobid
= print_parse_jobid(queue
[i
].fs_file
);
1175 if (jobid
== (uint32
)-1) {
1176 /* assume its a unix print job */
1177 print_unix_job(sharename
, &queue
[i
], jobid
);
1181 /* we have an active SMB print job - update its status */
1182 pjob
= print_job_find(sharename
, jobid
);
1184 /* err, somethings wrong. Probably smbd was restarted
1185 with jobs in the queue. All we can do is treat them
1186 like unix jobs. Pity. */
1187 print_unix_job(sharename
, &queue
[i
], jobid
);
1191 pjob
->sysjob
= queue
[i
].job
;
1193 /* don't reset the status on jobs to be deleted */
1195 if ( pjob
->status
!= LPQ_DELETING
)
1196 pjob
->status
= queue
[i
].status
;
1198 pjob_store(sharename
, jobid
, pjob
);
1200 check_job_changed(sharename
, jcdata
, jobid
);
1203 SAFE_FREE(jcdata
.dptr
);
1205 /* now delete any queued entries that don't appear in the
1207 tstruct
.queue
= queue
;
1208 tstruct
.qcount
= qcount
;
1210 tstruct
.total_jobs
= 0;
1211 tstruct
.lpq_time
= time(NULL
);
1212 tstruct
.sharename
= sharename
;
1213 tstruct
.lprm_command
= lprm_command
;
1214 tstruct
.print_if
= current_printif
;
1216 tdb_traverse(pdb
->tdb
, traverse_fn_delete
, (void *)&tstruct
);
1218 /* Store the linearised queue, max jobs only. */
1219 store_queue_struct(pdb
, &tstruct
);
1221 SAFE_FREE(tstruct
.queue
);
1223 DEBUG(10,("print_queue_update_internal: printer %s INFO/total_jobs = %d\n",
1224 sharename
, tstruct
.total_jobs
));
1226 tdb_store_int32(pdb
->tdb
, "INFO/total_jobs", tstruct
.total_jobs
);
1228 get_queue_status(sharename
, &old_status
);
1229 if (old_status
.qcount
!= qcount
)
1230 DEBUG(10,("print_queue_update_internal: queue status change %d jobs -> %d jobs for printer %s\n",
1231 old_status
.qcount
, qcount
, sharename
));
1233 /* store the new queue status structure */
1234 slprintf(keystr
, sizeof(keystr
)-1, "STATUS/%s", sharename
);
1236 key
.dsize
= strlen(keystr
);
1238 status
.qcount
= qcount
;
1239 data
.dptr
= (void *)&status
;
1240 data
.dsize
= sizeof(status
);
1241 tdb_store(pdb
->tdb
, key
, data
, TDB_REPLACE
);
1244 * Update the cache time again. We want to do this call
1245 * as little as possible...
1248 slprintf(keystr
, sizeof(keystr
)-1, "CACHE/%s", sharename
);
1249 tdb_store_int32(pdb
->tdb
, keystr
, (int32
)time(NULL
));
1251 /* clear the msg pending record for this queue */
1253 snprintf(keystr
, sizeof(keystr
), "MSG_PENDING/%s", sharename
);
1255 if ( !tdb_store_uint32( pdb
->tdb
, keystr
, 0 ) ) {
1256 /* log a message but continue on */
1258 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1262 release_print_db( pdb
);
1267 /****************************************************************************
1268 Update the internal database from the system print queue for a queue.
1269 obtain a lock on the print queue before proceeding (needed when mutiple
1270 smbd processes maytry to update the lpq cache concurrently).
1271 ****************************************************************************/
1273 static void print_queue_update_with_lock( const char *sharename
,
1274 struct printif
*current_printif
,
1275 char *lpq_command
, char *lprm_command
)
1278 struct tdb_print_db
*pdb
;
1280 DEBUG(5,("print_queue_update_with_lock: printer share = %s\n", sharename
));
1281 pdb
= get_print_db_byname(sharename
);
1285 if ( !print_cache_expired(sharename
, False
) ) {
1286 DEBUG(5,("print_queue_update_with_lock: print cache for %s is still ok\n", sharename
));
1287 release_print_db(pdb
);
1292 * Check to see if someone else is doing this update.
1293 * This is essentially a mutex on the update.
1296 if (get_updating_pid(sharename
) != -1) {
1297 release_print_db(pdb
);
1301 /* Lock the queue for the database update */
1303 slprintf(keystr
, sizeof(keystr
) - 1, "LOCK/%s", sharename
);
1304 /* Only wait 10 seconds for this. */
1305 if (tdb_lock_bystring_with_timeout(pdb
->tdb
, keystr
, 10) == -1) {
1306 DEBUG(0,("print_queue_update_with_lock: Failed to lock printer %s database\n", sharename
));
1307 release_print_db(pdb
);
1312 * Ensure that no one else got in here.
1313 * If the updating pid is still -1 then we are
1317 if (get_updating_pid(sharename
) != -1) {
1319 * Someone else is doing the update, exit.
1321 tdb_unlock_bystring(pdb
->tdb
, keystr
);
1322 release_print_db(pdb
);
1327 * We're going to do the update ourselves.
1330 /* Tell others we're doing the update. */
1331 set_updating_pid(sharename
, True
);
1334 * Allow others to enter and notice we're doing
1338 tdb_unlock_bystring(pdb
->tdb
, keystr
);
1340 /* do the main work now */
1342 print_queue_update_internal( sharename
, current_printif
,
1343 lpq_command
, lprm_command
);
1345 /* Delete our pid from the db. */
1346 set_updating_pid(sharename
, False
);
1347 release_print_db(pdb
);
1350 /****************************************************************************
1351 this is the receive function of the background lpq updater
1352 ****************************************************************************/
1353 static void print_queue_receive(int msg_type
, struct process_id src
,
1354 void *buf
, size_t msglen
)
1357 pstring lpqcommand
, lprmcommand
;
1361 len
= tdb_unpack( buf
, msglen
, "fdPP",
1368 DEBUG(0,("print_queue_receive: Got invalid print queue update message\n"));
1372 print_queue_update_with_lock(sharename
,
1373 get_printer_fns_from_type((enum printing_types
)printing_type
),
1374 lpqcommand
, lprmcommand
);
1379 static pid_t background_lpq_updater_pid
= -1;
1381 /****************************************************************************
1382 main thread of the background lpq updater
1383 ****************************************************************************/
1384 void start_background_queue(void)
1386 DEBUG(3,("start_background_queue: Starting background LPQ thread\n"));
1387 background_lpq_updater_pid
= sys_fork();
1389 if (background_lpq_updater_pid
== -1) {
1390 DEBUG(5,("start_background_queue: background LPQ thread failed to start. %s\n", strerror(errno
) ));
1394 if(background_lpq_updater_pid
== 0) {
1396 DEBUG(5,("start_background_queue: background LPQ thread started\n"));
1398 claim_connection( NULL
, "smbd lpq backend", 0, False
,
1399 FLAG_MSG_GENERAL
|FLAG_MSG_SMBD
|FLAG_MSG_PRINT_GENERAL
);
1401 if (!locking_init(0)) {
1405 message_register(MSG_PRINTER_UPDATE
, print_queue_receive
);
1407 DEBUG(5,("start_background_queue: background LPQ thread waiting for messages\n"));
1411 /* check for some essential signals first */
1414 exit_server_cleanly(NULL
);
1417 if (reload_after_sighup
) {
1418 change_to_root_user();
1419 DEBUG(1,("Reloading services after SIGHUP\n"));
1420 reload_services(False
);
1421 reload_after_sighup
= 0;
1424 /* now check for messages */
1426 DEBUG(10,("start_background_queue: background LPQ thread got a message\n"));
1429 /* process any pending print change notify messages */
1431 print_notify_send_messages(0);
1436 /****************************************************************************
1437 update the internal database from the system print queue for a queue
1438 ****************************************************************************/
1440 static void print_queue_update(int snum
, BOOL force
)
1444 pstring lpqcommand
, lprmcommand
;
1445 char *buffer
= NULL
;
1448 struct tdb_print_db
*pdb
;
1450 struct printif
*current_printif
;
1452 fstrcpy( sharename
, lp_const_servicename(snum
));
1454 /* don't strip out characters like '$' from the printername */
1456 pstrcpy( lpqcommand
, lp_lpqcommand(snum
));
1457 string_sub2( lpqcommand
, "%p", PRINTERNAME(snum
), sizeof(lpqcommand
),
1458 False
, False
, False
);
1459 standard_sub_snum( snum
, lpqcommand
, sizeof(lpqcommand
) );
1461 pstrcpy( lprmcommand
, lp_lprmcommand(snum
));
1462 string_sub2( lprmcommand
, "%p", PRINTERNAME(snum
), sizeof(lprmcommand
),
1463 False
, False
, False
);
1464 standard_sub_snum( snum
, lprmcommand
, sizeof(lprmcommand
) );
1467 * Make sure that the background queue process exists.
1468 * Otherwise just do the update ourselves
1471 if ( force
|| background_lpq_updater_pid
== -1 ) {
1472 DEBUG(4,("print_queue_update: updating queue [%s] myself\n", sharename
));
1473 current_printif
= get_printer_fns( snum
);
1474 print_queue_update_with_lock( sharename
, current_printif
, lpqcommand
, lprmcommand
);
1479 type
= lp_printing(snum
);
1481 /* get the length */
1483 len
= tdb_pack( NULL
, 0, "fdPP",
1489 buffer
= SMB_XMALLOC_ARRAY( char, len
);
1491 /* now pack the buffer */
1492 newlen
= tdb_pack( buffer
, len
, "fdPP",
1498 SMB_ASSERT( newlen
== len
);
1500 DEBUG(10,("print_queue_update: Sending message -> printer = %s, "
1501 "type = %d, lpq command = [%s] lprm command = [%s]\n",
1502 sharename
, type
, lpqcommand
, lprmcommand
));
1504 /* here we set a msg pending record for other smbd processes
1505 to throttle the number of duplicate print_queue_update msgs
1508 pdb
= get_print_db_byname(sharename
);
1514 snprintf(key
, sizeof(key
), "MSG_PENDING/%s", sharename
);
1516 if ( !tdb_store_uint32( pdb
->tdb
, key
, time(NULL
) ) ) {
1517 /* log a message but continue on */
1519 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1523 release_print_db( pdb
);
1525 /* finally send the message */
1528 message_send_pid(pid_to_procid(background_lpq_updater_pid
),
1529 MSG_PRINTER_UPDATE
, buffer
, len
, False
);
1532 SAFE_FREE( buffer
);
1537 /****************************************************************************
1538 Create/Update an entry in the print tdb that will allow us to send notify
1539 updates only to interested smbd's.
1540 ****************************************************************************/
1542 BOOL
print_notify_register_pid(int snum
)
1545 struct tdb_print_db
*pdb
= NULL
;
1546 TDB_CONTEXT
*tdb
= NULL
;
1547 const char *printername
;
1548 uint32 mypid
= (uint32
)sys_getpid();
1552 /* if (snum == -1), then the change notify request was
1553 on a print server handle and we need to register on
1558 int num_services
= lp_numservices();
1561 for ( idx
=0; idx
<num_services
; idx
++ ) {
1562 if (lp_snum_ok(idx
) && lp_print_ok(idx
) )
1563 print_notify_register_pid(idx
);
1568 else /* register for a specific printer */
1570 printername
= lp_const_servicename(snum
);
1571 pdb
= get_print_db_byname(printername
);
1577 if (tdb_lock_bystring_with_timeout(tdb
, NOTIFY_PID_LIST_KEY
, 10) == -1) {
1578 DEBUG(0,("print_notify_register_pid: Failed to lock printer %s\n",
1581 release_print_db(pdb
);
1585 data
= get_printer_notify_pid_list( tdb
, printername
, True
);
1587 /* Add ourselves and increase the refcount. */
1589 for (i
= 0; i
< data
.dsize
; i
+= 8) {
1590 if (IVAL(data
.dptr
,i
) == mypid
) {
1591 uint32 new_refcount
= IVAL(data
.dptr
, i
+4) + 1;
1592 SIVAL(data
.dptr
, i
+4, new_refcount
);
1597 if (i
== data
.dsize
) {
1598 /* We weren't in the list. Realloc. */
1599 data
.dptr
= SMB_REALLOC(data
.dptr
, data
.dsize
+ 8);
1601 DEBUG(0,("print_notify_register_pid: Relloc fail for printer %s\n",
1606 SIVAL(data
.dptr
,data
.dsize
- 8,mypid
);
1607 SIVAL(data
.dptr
,data
.dsize
- 4,1); /* Refcount. */
1610 /* Store back the record. */
1611 if (tdb_store_bystring(tdb
, NOTIFY_PID_LIST_KEY
, data
, TDB_REPLACE
) == -1) {
1612 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1613 list for printer %s\n", printername
));
1621 tdb_unlock_bystring(tdb
, NOTIFY_PID_LIST_KEY
);
1623 release_print_db(pdb
);
1624 SAFE_FREE(data
.dptr
);
1628 /****************************************************************************
1629 Update an entry in the print tdb that will allow us to send notify
1630 updates only to interested smbd's.
1631 ****************************************************************************/
1633 BOOL
print_notify_deregister_pid(int snum
)
1636 struct tdb_print_db
*pdb
= NULL
;
1637 TDB_CONTEXT
*tdb
= NULL
;
1638 const char *printername
;
1639 uint32 mypid
= (uint32
)sys_getpid();
1643 /* if ( snum == -1 ), we are deregister a print server handle
1644 which means to deregister on all print queues */
1648 int num_services
= lp_numservices();
1651 for ( idx
=0; idx
<num_services
; idx
++ ) {
1652 if ( lp_snum_ok(idx
) && lp_print_ok(idx
) )
1653 print_notify_deregister_pid(idx
);
1658 else /* deregister a specific printer */
1660 printername
= lp_const_servicename(snum
);
1661 pdb
= get_print_db_byname(printername
);
1667 if (tdb_lock_bystring_with_timeout(tdb
, NOTIFY_PID_LIST_KEY
, 10) == -1) {
1668 DEBUG(0,("print_notify_register_pid: Failed to lock \
1669 printer %s database\n", printername
));
1671 release_print_db(pdb
);
1675 data
= get_printer_notify_pid_list( tdb
, printername
, True
);
1677 /* Reduce refcount. Remove ourselves if zero. */
1679 for (i
= 0; i
< data
.dsize
; ) {
1680 if (IVAL(data
.dptr
,i
) == mypid
) {
1681 uint32 refcount
= IVAL(data
.dptr
, i
+4);
1685 if (refcount
== 0) {
1686 if (data
.dsize
- i
> 8)
1687 memmove( &data
.dptr
[i
], &data
.dptr
[i
+8], data
.dsize
- i
- 8);
1691 SIVAL(data
.dptr
, i
+4, refcount
);
1697 if (data
.dsize
== 0)
1698 SAFE_FREE(data
.dptr
);
1700 /* Store back the record. */
1701 if (tdb_store_bystring(tdb
, NOTIFY_PID_LIST_KEY
, data
, TDB_REPLACE
) == -1) {
1702 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1703 list for printer %s\n", printername
));
1711 tdb_unlock_bystring(tdb
, NOTIFY_PID_LIST_KEY
);
1713 release_print_db(pdb
);
1714 SAFE_FREE(data
.dptr
);
1718 /****************************************************************************
1719 Check if a jobid is valid. It is valid if it exists in the database.
1720 ****************************************************************************/
1722 BOOL
print_job_exists(const char* sharename
, uint32 jobid
)
1724 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1729 ret
= tdb_exists(pdb
->tdb
, print_key(jobid
));
1730 release_print_db(pdb
);
1734 /****************************************************************************
1735 Give the fd used for a jobid.
1736 ****************************************************************************/
1738 int print_job_fd(const char* sharename
, uint32 jobid
)
1740 struct printjob
*pjob
= print_job_find(sharename
, jobid
);
1743 /* don't allow another process to get this info - it is meaningless */
1744 if (pjob
->pid
!= sys_getpid())
1749 /****************************************************************************
1750 Give the filename used for a jobid.
1751 Only valid for the process doing the spooling and when the job
1752 has not been spooled.
1753 ****************************************************************************/
1755 char *print_job_fname(const char* sharename
, uint32 jobid
)
1757 struct printjob
*pjob
= print_job_find(sharename
, jobid
);
1758 if (!pjob
|| pjob
->spooled
|| pjob
->pid
!= sys_getpid())
1760 return pjob
->filename
;
1764 /****************************************************************************
1765 Give the filename used for a jobid.
1766 Only valid for the process doing the spooling and when the job
1767 has not been spooled.
1768 ****************************************************************************/
1770 NT_DEVICEMODE
*print_job_devmode(const char* sharename
, uint32 jobid
)
1772 struct printjob
*pjob
= print_job_find(sharename
, jobid
);
1777 return pjob
->nt_devmode
;
1780 /****************************************************************************
1781 Set the place in the queue for a job.
1782 ****************************************************************************/
1784 BOOL
print_job_set_place(int snum
, uint32 jobid
, int place
)
1786 DEBUG(2,("print_job_set_place not implemented yet\n"));
1790 /****************************************************************************
1791 Set the name of a job. Only possible for owner.
1792 ****************************************************************************/
1794 BOOL
print_job_set_name(int snum
, uint32 jobid
, char *name
)
1796 const char* sharename
= lp_const_servicename(snum
);
1797 struct printjob
*pjob
;
1799 pjob
= print_job_find(sharename
, jobid
);
1800 if (!pjob
|| pjob
->pid
!= sys_getpid())
1803 fstrcpy(pjob
->jobname
, name
);
1804 return pjob_store(sharename
, jobid
, pjob
);
1807 /***************************************************************************
1808 Remove a jobid from the 'jobs changed' list.
1809 ***************************************************************************/
1811 static BOOL
remove_from_jobs_changed(const char* sharename
, uint32 jobid
)
1813 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1815 size_t job_count
, i
;
1817 BOOL gotlock
= False
;
1825 key
= string_tdb_data("INFO/jobs_changed");
1827 if (tdb_chainlock_with_timeout(pdb
->tdb
, key
, 5) == -1)
1832 data
= tdb_fetch(pdb
->tdb
, key
);
1834 if (data
.dptr
== NULL
|| data
.dsize
== 0 || (data
.dsize
% 4 != 0))
1837 job_count
= data
.dsize
/ 4;
1838 for (i
= 0; i
< job_count
; i
++) {
1841 ch_jobid
= IVAL(data
.dptr
, i
*4);
1842 if (ch_jobid
== jobid
) {
1843 if (i
< job_count
-1 )
1844 memmove(data
.dptr
+ (i
*4), data
.dptr
+ (i
*4) + 4, (job_count
- i
- 1)*4 );
1846 if (tdb_store(pdb
->tdb
, key
, data
, TDB_REPLACE
) == -1)
1856 tdb_chainunlock(pdb
->tdb
, key
);
1857 SAFE_FREE(data
.dptr
);
1858 release_print_db(pdb
);
1860 DEBUG(10,("remove_from_jobs_changed: removed jobid %u\n", (unsigned int)jobid
));
1862 DEBUG(10,("remove_from_jobs_changed: Failed to remove jobid %u\n", (unsigned int)jobid
));
1866 /****************************************************************************
1867 Delete a print job - don't update queue.
1868 ****************************************************************************/
1870 static BOOL
print_job_delete1(int snum
, uint32 jobid
)
1872 const char* sharename
= lp_const_servicename(snum
);
1873 struct printjob
*pjob
= print_job_find(sharename
, jobid
);
1875 struct printif
*current_printif
= get_printer_fns( snum
);
1881 * If already deleting just return.
1884 if (pjob
->status
== LPQ_DELETING
)
1887 /* Hrm - we need to be able to cope with deleting a job before it
1888 has reached the spooler. Just mark it as LPQ_DELETING and
1889 let the print_queue_update() code rmeove the record */
1892 if (pjob
->sysjob
== -1) {
1893 DEBUG(5, ("attempt to delete job %u not seen by lpr\n", (unsigned int)jobid
));
1896 /* Set the tdb entry to be deleting. */
1898 pjob
->status
= LPQ_DELETING
;
1899 pjob_store(sharename
, jobid
, pjob
);
1901 if (pjob
->spooled
&& pjob
->sysjob
!= -1)
1903 result
= (*(current_printif
->job_delete
))(
1905 lp_lprmcommand(snum
),
1908 /* Delete the tdb entry if the delete succeeded or the job hasn't
1912 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
1917 pjob_delete(sharename
, jobid
);
1918 /* Ensure we keep a rough count of the number of total jobs... */
1919 tdb_change_int32_atomic(pdb
->tdb
, "INFO/total_jobs", &njobs
, -1);
1920 release_print_db(pdb
);
1924 remove_from_jobs_changed( sharename
, jobid
);
1926 return (result
== 0);
1929 /****************************************************************************
1930 Return true if the current user owns the print job.
1931 ****************************************************************************/
1933 static BOOL
is_owner(struct current_user
*user
, int snum
, uint32 jobid
)
1935 struct printjob
*pjob
= print_job_find(lp_const_servicename(snum
), jobid
);
1941 if ((vuser
= get_valid_user_struct(user
->vuid
)) != NULL
) {
1942 return strequal(pjob
->user
, vuser
->user
.smb_name
);
1944 return strequal(pjob
->user
, uidtoname(user
->ut
.uid
));
1948 /****************************************************************************
1950 ****************************************************************************/
1952 BOOL
print_job_delete(struct current_user
*user
, int snum
, uint32 jobid
, WERROR
*errcode
)
1954 const char* sharename
= lp_const_servicename( snum
);
1955 struct printjob
*pjob
;
1961 owner
= is_owner(user
, snum
, jobid
);
1963 /* Check access against security descriptor or whether the user
1967 !print_access_check(user
, snum
, JOB_ACCESS_ADMINISTER
)) {
1968 DEBUG(3, ("delete denied by security descriptor\n"));
1969 *errcode
= WERR_ACCESS_DENIED
;
1971 /* BEGIN_ADMIN_LOG */
1972 sys_adminlog( LOG_ERR
,
1973 "Permission denied-- user not allowed to delete, \
1974 pause, or resume print job. User name: %s. Printer name: %s.",
1975 uidtoname(user
->ut
.uid
), PRINTERNAME(snum
) );
1982 * get the spooled filename of the print job
1983 * if this works, then the file has not been spooled
1984 * to the underlying print system. Just delete the
1985 * spool file & return.
1988 if ( (fname
= print_job_fname( sharename
, jobid
)) != NULL
)
1990 /* remove the spool file */
1991 DEBUG(10,("print_job_delete: Removing spool file [%s]\n", fname
));
1992 if ( unlink( fname
) == -1 ) {
1993 *errcode
= map_werror_from_unix(errno
);
1998 if (!print_job_delete1(snum
, jobid
)) {
1999 *errcode
= WERR_ACCESS_DENIED
;
2003 /* force update the database and say the delete failed if the
2006 print_queue_update(snum
, True
);
2008 pjob
= print_job_find(sharename
, jobid
);
2009 if ( pjob
&& (pjob
->status
!= LPQ_DELETING
) )
2010 *errcode
= WERR_ACCESS_DENIED
;
2012 return (pjob
== NULL
);
2015 /****************************************************************************
2017 ****************************************************************************/
2019 BOOL
print_job_pause(struct current_user
*user
, int snum
, uint32 jobid
, WERROR
*errcode
)
2021 const char* sharename
= lp_const_servicename(snum
);
2022 struct printjob
*pjob
;
2024 struct printif
*current_printif
= get_printer_fns( snum
);
2026 pjob
= print_job_find(sharename
, jobid
);
2028 if (!pjob
|| !user
) {
2029 DEBUG(10, ("print_job_pause: no pjob or user for jobid %u\n",
2030 (unsigned int)jobid
));
2034 if (!pjob
->spooled
|| pjob
->sysjob
== -1) {
2035 DEBUG(10, ("print_job_pause: not spooled or bad sysjob = %d for jobid %u\n",
2036 (int)pjob
->sysjob
, (unsigned int)jobid
));
2040 if (!is_owner(user
, snum
, jobid
) &&
2041 !print_access_check(user
, snum
, JOB_ACCESS_ADMINISTER
)) {
2042 DEBUG(3, ("pause denied by security descriptor\n"));
2044 /* BEGIN_ADMIN_LOG */
2045 sys_adminlog( LOG_ERR
,
2046 "Permission denied-- user not allowed to delete, \
2047 pause, or resume print job. User name: %s. Printer name: %s.",
2048 uidtoname(user
->ut
.uid
), PRINTERNAME(snum
) );
2051 *errcode
= WERR_ACCESS_DENIED
;
2055 /* need to pause the spooled entry */
2056 ret
= (*(current_printif
->job_pause
))(snum
, pjob
);
2059 *errcode
= WERR_INVALID_PARAM
;
2063 /* force update the database */
2064 print_cache_flush(snum
);
2066 /* Send a printer notify message */
2068 notify_job_status(sharename
, jobid
, JOB_STATUS_PAUSED
);
2070 /* how do we tell if this succeeded? */
2075 /****************************************************************************
2077 ****************************************************************************/
2079 BOOL
print_job_resume(struct current_user
*user
, int snum
, uint32 jobid
, WERROR
*errcode
)
2081 const char *sharename
= lp_const_servicename(snum
);
2082 struct printjob
*pjob
;
2084 struct printif
*current_printif
= get_printer_fns( snum
);
2086 pjob
= print_job_find(sharename
, jobid
);
2088 if (!pjob
|| !user
) {
2089 DEBUG(10, ("print_job_resume: no pjob or user for jobid %u\n",
2090 (unsigned int)jobid
));
2094 if (!pjob
->spooled
|| pjob
->sysjob
== -1) {
2095 DEBUG(10, ("print_job_resume: not spooled or bad sysjob = %d for jobid %u\n",
2096 (int)pjob
->sysjob
, (unsigned int)jobid
));
2100 if (!is_owner(user
, snum
, jobid
) &&
2101 !print_access_check(user
, snum
, JOB_ACCESS_ADMINISTER
)) {
2102 DEBUG(3, ("resume denied by security descriptor\n"));
2103 *errcode
= WERR_ACCESS_DENIED
;
2105 /* BEGIN_ADMIN_LOG */
2106 sys_adminlog( LOG_ERR
,
2107 "Permission denied-- user not allowed to delete, \
2108 pause, or resume print job. User name: %s. Printer name: %s.",
2109 uidtoname(user
->ut
.uid
), PRINTERNAME(snum
) );
2114 ret
= (*(current_printif
->job_resume
))(snum
, pjob
);
2117 *errcode
= WERR_INVALID_PARAM
;
2121 /* force update the database */
2122 print_cache_flush(snum
);
2124 /* Send a printer notify message */
2126 notify_job_status(sharename
, jobid
, JOB_STATUS_QUEUED
);
2131 /****************************************************************************
2132 Write to a print file.
2133 ****************************************************************************/
2135 ssize_t
print_job_write(int snum
, uint32 jobid
, const char *buf
, SMB_OFF_T pos
, size_t size
)
2137 const char* sharename
= lp_const_servicename(snum
);
2139 struct printjob
*pjob
;
2141 pjob
= print_job_find(sharename
, jobid
);
2145 /* don't allow another process to get this info - it is meaningless */
2146 if (pjob
->pid
!= sys_getpid())
2149 return_code
= write_data_at_offset(pjob
->fd
, buf
, size
, pos
);
2151 if (return_code
>0) {
2153 pjob_store(sharename
, jobid
, pjob
);
2158 /****************************************************************************
2159 Get the queue status - do not update if db is out of date.
2160 ****************************************************************************/
2162 static int get_queue_status(const char* sharename
, print_status_struct
*status
)
2166 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
2170 ZERO_STRUCTP(status
);
2177 fstr_sprintf(keystr
, "STATUS/%s", sharename
);
2178 data
= tdb_fetch(pdb
->tdb
, string_tdb_data(keystr
));
2180 if (data
.dsize
== sizeof(print_status_struct
))
2181 /* this memcpy is ok since the status struct was
2182 not packed before storing it in the tdb */
2183 memcpy(status
, data
.dptr
, sizeof(print_status_struct
));
2184 SAFE_FREE(data
.dptr
);
2187 len
= tdb_fetch_int32(pdb
->tdb
, "INFO/total_jobs");
2188 release_print_db(pdb
);
2189 return (len
== -1 ? 0 : len
);
2192 /****************************************************************************
2193 Determine the number of jobs in a queue.
2194 ****************************************************************************/
2196 int print_queue_length(int snum
, print_status_struct
*pstatus
)
2198 const char* sharename
= lp_const_servicename( snum
);
2199 print_status_struct status
;
2202 ZERO_STRUCT( status
);
2204 /* make sure the database is up to date */
2205 if (print_cache_expired(lp_const_servicename(snum
), True
))
2206 print_queue_update(snum
, False
);
2208 /* also fetch the queue status */
2209 memset(&status
, 0, sizeof(status
));
2210 len
= get_queue_status(sharename
, &status
);
2218 /***************************************************************************
2219 Allocate a jobid. Hold the lock for as short a time as possible.
2220 ***************************************************************************/
2222 static BOOL
allocate_print_jobid(struct tdb_print_db
*pdb
, int snum
, const char *sharename
, uint32
*pjobid
)
2227 *pjobid
= (uint32
)-1;
2229 for (i
= 0; i
< 3; i
++) {
2230 /* Lock the database - only wait 20 seconds. */
2231 if (tdb_lock_bystring_with_timeout(pdb
->tdb
, "INFO/nextjob", 20) == -1) {
2232 DEBUG(0,("allocate_print_jobid: failed to lock printing database %s\n", sharename
));
2236 if (!tdb_fetch_uint32(pdb
->tdb
, "INFO/nextjob", &jobid
)) {
2237 if (tdb_error(pdb
->tdb
) != TDB_ERR_NOEXIST
) {
2238 DEBUG(0, ("allocate_print_jobid: failed to fetch INFO/nextjob for print queue %s\n",
2245 jobid
= NEXT_JOBID(jobid
);
2247 if (tdb_store_int32(pdb
->tdb
, "INFO/nextjob", jobid
)==-1) {
2248 DEBUG(3, ("allocate_print_jobid: failed to store INFO/nextjob.\n"));
2249 tdb_unlock_bystring(pdb
->tdb
, "INFO/nextjob");
2253 /* We've finished with the INFO/nextjob lock. */
2254 tdb_unlock_bystring(pdb
->tdb
, "INFO/nextjob");
2256 if (!print_job_exists(sharename
, jobid
))
2261 DEBUG(0, ("allocate_print_jobid: failed to allocate a print job for queue %s\n",
2263 /* Probably full... */
2268 /* Store a dummy placeholder. */
2273 if (tdb_store(pdb
->tdb
, print_key(jobid
), dum
, TDB_INSERT
) == -1) {
2274 DEBUG(3, ("allocate_print_jobid: jobid (%d) failed to store placeholder.\n",
2284 /***************************************************************************
2285 Append a jobid to the 'jobs changed' list.
2286 ***************************************************************************/
2288 static BOOL
add_to_jobs_changed(struct tdb_print_db
*pdb
, uint32 jobid
)
2293 SIVAL(&store_jobid
, 0, jobid
);
2294 data
.dptr
= (char *)&store_jobid
;
2297 DEBUG(10,("add_to_jobs_changed: Added jobid %u\n", (unsigned int)jobid
));
2299 return (tdb_append(pdb
->tdb
, string_tdb_data("INFO/jobs_changed"),
2303 /***************************************************************************
2304 Start spooling a job - return the jobid.
2305 ***************************************************************************/
2307 uint32
print_job_start(struct current_user
*user
, int snum
, char *jobname
, NT_DEVICEMODE
*nt_devmode
)
2311 struct printjob pjob
;
2313 const char *sharename
= lp_const_servicename(snum
);
2314 struct tdb_print_db
*pdb
= get_print_db_byname(sharename
);
2322 if (!print_access_check(user
, snum
, PRINTER_ACCESS_USE
)) {
2323 DEBUG(3, ("print_job_start: job start denied by security descriptor\n"));
2324 release_print_db(pdb
);
2328 if (!print_time_access_check(snum
)) {
2329 DEBUG(3, ("print_job_start: job start denied by time check\n"));
2330 release_print_db(pdb
);
2334 path
= lp_pathname(snum
);
2336 /* see if we have sufficient disk space */
2337 if (lp_minprintspace(snum
)) {
2338 SMB_BIG_UINT dspace
, dsize
;
2339 if (sys_fsusage(path
, &dspace
, &dsize
) == 0 &&
2340 dspace
< 2*(SMB_BIG_UINT
)lp_minprintspace(snum
)) {
2341 DEBUG(3, ("print_job_start: disk space check failed.\n"));
2342 release_print_db(pdb
);
2348 /* for autoloaded printers, check that the printcap entry still exists */
2349 if (lp_autoloaded(snum
) && !pcap_printername_ok(lp_const_servicename(snum
))) {
2350 DEBUG(3, ("print_job_start: printer name %s check failed.\n", lp_const_servicename(snum
) ));
2351 release_print_db(pdb
);
2356 /* Insure the maximum queue size is not violated */
2357 if ((njobs
= print_queue_length(snum
,NULL
)) > lp_maxprintjobs(snum
)) {
2358 DEBUG(3, ("print_job_start: Queue %s number of jobs (%d) larger than max printjobs per queue (%d).\n",
2359 sharename
, njobs
, lp_maxprintjobs(snum
) ));
2360 release_print_db(pdb
);
2365 DEBUG(10,("print_job_start: Queue %s number of jobs (%d), max printjobs = %d\n",
2366 sharename
, njobs
, lp_maxprintjobs(snum
) ));
2368 if (!allocate_print_jobid(pdb
, snum
, sharename
, &jobid
))
2371 /* create the database entry */
2375 pjob
.pid
= sys_getpid();
2378 pjob
.starttime
= time(NULL
);
2379 pjob
.status
= LPQ_SPOOLING
;
2381 pjob
.spooled
= False
;
2383 pjob
.nt_devmode
= nt_devmode
;
2385 fstrcpy(pjob
.jobname
, jobname
);
2387 if ((vuser
= get_valid_user_struct(user
->vuid
)) != NULL
) {
2388 fstrcpy(pjob
.user
, vuser
->user
.smb_name
);
2390 fstrcpy(pjob
.user
, uidtoname(user
->ut
.uid
));
2393 fstrcpy(pjob
.queuename
, lp_const_servicename(snum
));
2395 /* we have a job entry - now create the spool file */
2396 slprintf(pjob
.filename
, sizeof(pjob
.filename
)-1, "%s/%s%.8u.XXXXXX",
2397 path
, PRINT_SPOOL_PREFIX
, (unsigned int)jobid
);
2398 pjob
.fd
= smb_mkstemp(pjob
.filename
);
2400 if (pjob
.fd
== -1) {
2401 if (errno
== EACCES
) {
2402 /* Common setup error, force a report. */
2403 DEBUG(0, ("print_job_start: insufficient permissions \
2404 to open spool file %s.\n", pjob
.filename
));
2406 /* Normal case, report at level 3 and above. */
2407 DEBUG(3, ("print_job_start: can't open spool file %s,\n", pjob
.filename
));
2408 DEBUGADD(3, ("errno = %d (%s).\n", errno
, strerror(errno
)));
2413 pjob_store(sharename
, jobid
, &pjob
);
2415 /* Update the 'jobs changed' entry used by print_queue_status. */
2416 add_to_jobs_changed(pdb
, jobid
);
2418 /* Ensure we keep a rough count of the number of total jobs... */
2419 tdb_change_int32_atomic(pdb
->tdb
, "INFO/total_jobs", &njobs
, 1);
2421 release_print_db(pdb
);
2427 pjob_delete(sharename
, jobid
);
2429 release_print_db(pdb
);
2431 DEBUG(3, ("print_job_start: returning fail. Error = %s\n", strerror(errno
) ));
2435 /****************************************************************************
2436 Update the number of pages spooled to jobid
2437 ****************************************************************************/
2439 void print_job_endpage(int snum
, uint32 jobid
)
2441 const char* sharename
= lp_const_servicename(snum
);
2442 struct printjob
*pjob
;
2444 pjob
= print_job_find(sharename
, jobid
);
2447 /* don't allow another process to get this info - it is meaningless */
2448 if (pjob
->pid
!= sys_getpid())
2452 pjob_store(sharename
, jobid
, pjob
);
2455 /****************************************************************************
2456 Print a file - called on closing the file. This spools the job.
2457 If normal close is false then we're tearing down the jobs - treat as an
2459 ****************************************************************************/
2461 BOOL
print_job_end(int snum
, uint32 jobid
, enum file_close_type close_type
)
2463 const char* sharename
= lp_const_servicename(snum
);
2464 struct printjob
*pjob
;
2466 SMB_STRUCT_STAT sbuf
;
2467 struct printif
*current_printif
= get_printer_fns( snum
);
2469 pjob
= print_job_find(sharename
, jobid
);
2474 if (pjob
->spooled
|| pjob
->pid
!= sys_getpid())
2477 if ((close_type
== NORMAL_CLOSE
|| close_type
== SHUTDOWN_CLOSE
) &&
2478 (sys_fstat(pjob
->fd
, &sbuf
) == 0)) {
2479 pjob
->size
= sbuf
.st_size
;
2485 * Not a normal close or we couldn't stat the job file,
2486 * so something has gone wrong. Cleanup.
2490 DEBUG(3,("print_job_end: failed to stat file for jobid %d\n", jobid
));
2494 /* Technically, this is not quite right. If the printer has a separator
2495 * page turned on, the NT spooler prints the separator page even if the
2496 * print job is 0 bytes. 010215 JRR */
2497 if (pjob
->size
== 0 || pjob
->status
== LPQ_DELETING
) {
2498 /* don't bother spooling empty files or something being deleted. */
2499 DEBUG(5,("print_job_end: canceling spool of %s (%s)\n",
2500 pjob
->filename
, pjob
->size
? "deleted" : "zero length" ));
2501 unlink(pjob
->filename
);
2502 pjob_delete(sharename
, jobid
);
2506 pjob
->smbjob
= jobid
;
2508 ret
= (*(current_printif
->job_submit
))(snum
, pjob
);
2513 /* The print job has been sucessfully handed over to the back-end */
2515 pjob
->spooled
= True
;
2516 pjob
->status
= LPQ_QUEUED
;
2517 pjob_store(sharename
, jobid
, pjob
);
2519 /* make sure the database is up to date */
2520 if (print_cache_expired(lp_const_servicename(snum
), True
))
2521 print_queue_update(snum
, False
);
2527 /* The print job was not succesfully started. Cleanup */
2528 /* Still need to add proper error return propagation! 010122:JRR */
2529 unlink(pjob
->filename
);
2530 pjob_delete(sharename
, jobid
);
2534 /****************************************************************************
2535 Get a snapshot of jobs in the system without traversing.
2536 ****************************************************************************/
2538 static BOOL
get_stored_queue_info(struct tdb_print_db
*pdb
, int snum
, int *pcount
, print_queue_struct
**ppqueue
)
2540 TDB_DATA data
, cgdata
;
2541 print_queue_struct
*queue
= NULL
;
2543 uint32 extra_count
= 0;
2544 int total_count
= 0;
2547 int max_reported_jobs
= lp_max_reported_jobs(snum
);
2549 const char* sharename
= lp_servicename(snum
);
2551 /* make sure the database is up to date */
2552 if (print_cache_expired(lp_const_servicename(snum
), True
))
2553 print_queue_update(snum
, False
);
2559 ZERO_STRUCT(cgdata
);
2561 /* Get the stored queue data. */
2562 data
= tdb_fetch(pdb
->tdb
, string_tdb_data("INFO/linear_queue_array"));
2564 if (data
.dptr
&& data
.dsize
>= sizeof(qcount
))
2565 len
+= tdb_unpack(data
.dptr
+ len
, data
.dsize
- len
, "d", &qcount
);
2567 /* Get the changed jobs list. */
2568 cgdata
= tdb_fetch(pdb
->tdb
, string_tdb_data("INFO/jobs_changed"));
2569 if (cgdata
.dptr
!= NULL
&& (cgdata
.dsize
% 4 == 0))
2570 extra_count
= cgdata
.dsize
/4;
2572 DEBUG(5,("get_stored_queue_info: qcount = %u, extra_count = %u\n", (unsigned int)qcount
, (unsigned int)extra_count
));
2574 /* Allocate the queue size. */
2575 if (qcount
== 0 && extra_count
== 0)
2578 if ((queue
= SMB_MALLOC_ARRAY(print_queue_struct
, qcount
+ extra_count
)) == NULL
)
2581 /* Retrieve the linearised queue data. */
2583 for( i
= 0; i
< qcount
; i
++) {
2584 uint32 qjob
, qsize
, qpage_count
, qstatus
, qpriority
, qtime
;
2585 len
+= tdb_unpack(data
.dptr
+ len
, data
.dsize
- len
, "ddddddff",
2594 queue
[i
].job
= qjob
;
2595 queue
[i
].size
= qsize
;
2596 queue
[i
].page_count
= qpage_count
;
2597 queue
[i
].status
= qstatus
;
2598 queue
[i
].priority
= qpriority
;
2599 queue
[i
].time
= qtime
;
2602 total_count
= qcount
;
2604 /* Add in the changed jobids. */
2605 for( i
= 0; i
< extra_count
; i
++) {
2607 struct printjob
*pjob
;
2609 jobid
= IVAL(cgdata
.dptr
, i
*4);
2610 DEBUG(5,("get_stored_queue_info: changed job = %u\n", (unsigned int)jobid
));
2611 pjob
= print_job_find(lp_const_servicename(snum
), jobid
);
2613 DEBUG(5,("get_stored_queue_info: failed to find changed job = %u\n", (unsigned int)jobid
));
2614 remove_from_jobs_changed(sharename
, jobid
);
2618 queue
[total_count
].job
= jobid
;
2619 queue
[total_count
].size
= pjob
->size
;
2620 queue
[total_count
].page_count
= pjob
->page_count
;
2621 queue
[total_count
].status
= pjob
->status
;
2622 queue
[total_count
].priority
= 1;
2623 queue
[total_count
].time
= pjob
->starttime
;
2624 fstrcpy(queue
[total_count
].fs_user
, pjob
->user
);
2625 fstrcpy(queue
[total_count
].fs_file
, pjob
->jobname
);
2629 /* Sort the queue by submission time otherwise they are displayed
2632 qsort(queue
, total_count
, sizeof(print_queue_struct
), QSORT_CAST(printjob_comp
));
2634 DEBUG(5,("get_stored_queue_info: total_count = %u\n", (unsigned int)total_count
));
2636 if (max_reported_jobs
&& total_count
> max_reported_jobs
)
2637 total_count
= max_reported_jobs
;
2640 *pcount
= total_count
;
2646 SAFE_FREE(data
.dptr
);
2647 SAFE_FREE(cgdata
.dptr
);
2651 /****************************************************************************
2652 Get a printer queue listing.
2653 set queue = NULL and status = NULL if you just want to update the cache
2654 ****************************************************************************/
2656 int print_queue_status(int snum
,
2657 print_queue_struct
**ppqueue
,
2658 print_status_struct
*status
)
2662 const char *sharename
;
2663 struct tdb_print_db
*pdb
;
2666 /* make sure the database is up to date */
2668 if (print_cache_expired(lp_const_servicename(snum
), True
))
2669 print_queue_update(snum
, False
);
2671 /* return if we are done */
2672 if ( !ppqueue
|| !status
)
2676 sharename
= lp_const_servicename(snum
);
2677 pdb
= get_print_db_byname(sharename
);
2683 * Fetch the queue status. We must do this first, as there may
2684 * be no jobs in the queue.
2687 ZERO_STRUCTP(status
);
2688 slprintf(keystr
, sizeof(keystr
)-1, "STATUS/%s", sharename
);
2690 key
.dsize
= strlen(keystr
);
2691 data
= tdb_fetch(pdb
->tdb
, key
);
2693 if (data
.dsize
== sizeof(*status
)) {
2694 /* this memcpy is ok since the status struct was
2695 not packed before storing it in the tdb */
2696 memcpy(status
, data
.dptr
, sizeof(*status
));
2698 SAFE_FREE(data
.dptr
);
2702 * Now, fetch the print queue information. We first count the number
2703 * of entries, and then only retrieve the queue if necessary.
2706 if (!get_stored_queue_info(pdb
, snum
, &count
, ppqueue
)) {
2707 release_print_db(pdb
);
2711 release_print_db(pdb
);
2715 /****************************************************************************
2717 ****************************************************************************/
2719 BOOL
print_queue_pause(struct current_user
*user
, int snum
, WERROR
*errcode
)
2722 struct printif
*current_printif
= get_printer_fns( snum
);
2724 if (!print_access_check(user
, snum
, PRINTER_ACCESS_ADMINISTER
)) {
2725 *errcode
= WERR_ACCESS_DENIED
;
2732 ret
= (*(current_printif
->queue_pause
))(snum
);
2737 *errcode
= WERR_INVALID_PARAM
;
2741 /* force update the database */
2742 print_cache_flush(snum
);
2744 /* Send a printer notify message */
2746 notify_printer_status(snum
, PRINTER_STATUS_PAUSED
);
2751 /****************************************************************************
2753 ****************************************************************************/
2755 BOOL
print_queue_resume(struct current_user
*user
, int snum
, WERROR
*errcode
)
2758 struct printif
*current_printif
= get_printer_fns( snum
);
2760 if (!print_access_check(user
, snum
, PRINTER_ACCESS_ADMINISTER
)) {
2761 *errcode
= WERR_ACCESS_DENIED
;
2767 ret
= (*(current_printif
->queue_resume
))(snum
);
2772 *errcode
= WERR_INVALID_PARAM
;
2776 /* make sure the database is up to date */
2777 if (print_cache_expired(lp_const_servicename(snum
), True
))
2778 print_queue_update(snum
, True
);
2780 /* Send a printer notify message */
2782 notify_printer_status(snum
, PRINTER_STATUS_OK
);
2787 /****************************************************************************
2788 Purge a queue - implemented by deleting all jobs that we can delete.
2789 ****************************************************************************/
2791 BOOL
print_queue_purge(struct current_user
*user
, int snum
, WERROR
*errcode
)
2793 print_queue_struct
*queue
;
2794 print_status_struct status
;
2798 /* Force and update so the count is accurate (i.e. not a cached count) */
2799 print_queue_update(snum
, True
);
2801 can_job_admin
= print_access_check(user
, snum
, JOB_ACCESS_ADMINISTER
);
2802 njobs
= print_queue_status(snum
, &queue
, &status
);
2804 if ( can_job_admin
)
2807 for (i
=0;i
<njobs
;i
++) {
2808 BOOL owner
= is_owner(user
, snum
, queue
[i
].job
);
2810 if (owner
|| can_job_admin
) {
2811 print_job_delete1(snum
, queue
[i
].job
);
2815 if ( can_job_admin
)
2818 /* update the cache */
2819 print_queue_update( snum
, True
);