2 Unix SMB/Netbios implementation.
4 printing backend routines
5 Copyright (C) Andrew Tridgell 1992-2000
6 Copyright (C) Jeremy Allison 2002
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
25 extern struct current_user current_user;
26 extern userdom_struct current_user_info;
28 /* Current printer interface */
29 static bool remove_from_jobs_changed(const char* sharename, uint32 jobid);
32 the printing backend revolves around a tdb database that stores the
33 SMB view of the print queue
35 The key for this database is a jobid - a internally generated number that
36 uniquely identifies a print job
38 reading the print queue involves two steps:
39 - possibly running lpq and updating the internal database from that
40 - reading entries from the database
42 jobids are assigned when a job starts spooling.
45 static TDB_CONTEXT *rap_tdb;
46 static uint16 next_rap_jobid;
47 struct rap_jobid_key {
52 /***************************************************************************
53 Nightmare. LANMAN jobid's are 16 bit numbers..... We must map them to 32
54 bit RPC jobids.... JRA.
55 ***************************************************************************/
57 uint16 pjobid_to_rap(const char* sharename, uint32 jobid)
61 struct rap_jobid_key jinfo;
64 DEBUG(10,("pjobid_to_rap: called.\n"));
67 /* Create the in-memory tdb. */
68 rap_tdb = tdb_open_log(NULL, 0, TDB_INTERNAL, (O_RDWR|O_CREAT), 0644);
74 fstrcpy( jinfo.sharename, sharename );
76 key.dptr = (uint8 *)&jinfo;
77 key.dsize = sizeof(jinfo);
79 data = tdb_fetch(rap_tdb, key);
80 if (data.dptr && data.dsize == sizeof(uint16)) {
81 rap_jobid = SVAL(data.dptr, 0);
83 DEBUG(10,("pjobid_to_rap: jobid %u maps to RAP jobid %u\n",
84 (unsigned int)jobid, (unsigned int)rap_jobid));
88 /* Not found - create and store mapping. */
89 rap_jobid = ++next_rap_jobid;
91 rap_jobid = ++next_rap_jobid;
92 SSVAL(buf,0,rap_jobid);
94 data.dsize = sizeof(rap_jobid);
95 tdb_store(rap_tdb, key, data, TDB_REPLACE);
96 tdb_store(rap_tdb, data, key, TDB_REPLACE);
98 DEBUG(10,("pjobid_to_rap: created jobid %u maps to RAP jobid %u\n",
99 (unsigned int)jobid, (unsigned int)rap_jobid));
103 bool rap_to_pjobid(uint16 rap_jobid, fstring sharename, uint32 *pjobid)
108 DEBUG(10,("rap_to_pjobid called.\n"));
113 SSVAL(buf,0,rap_jobid);
115 key.dsize = sizeof(rap_jobid);
116 data = tdb_fetch(rap_tdb, key);
117 if ( data.dptr && data.dsize == sizeof(struct rap_jobid_key) )
119 struct rap_jobid_key *jinfo = (struct rap_jobid_key*)data.dptr;
120 if (sharename != NULL) {
121 fstrcpy( sharename, jinfo->sharename );
123 *pjobid = jinfo->jobid;
124 DEBUG(10,("rap_to_pjobid: jobid %u maps to RAP jobid %u\n",
125 (unsigned int)*pjobid, (unsigned int)rap_jobid));
126 SAFE_FREE(data.dptr);
130 DEBUG(10,("rap_to_pjobid: Failed to lookup RAP jobid %u\n",
131 (unsigned int)rap_jobid));
132 SAFE_FREE(data.dptr);
136 static void rap_jobid_delete(const char* sharename, uint32 jobid)
140 struct rap_jobid_key jinfo;
143 DEBUG(10,("rap_jobid_delete: called.\n"));
148 ZERO_STRUCT( jinfo );
149 fstrcpy( jinfo.sharename, sharename );
151 key.dptr = (uint8 *)&jinfo;
152 key.dsize = sizeof(jinfo);
154 data = tdb_fetch(rap_tdb, key);
155 if (!data.dptr || (data.dsize != sizeof(uint16))) {
156 DEBUG(10,("rap_jobid_delete: cannot find jobid %u\n",
157 (unsigned int)jobid ));
158 SAFE_FREE(data.dptr);
162 DEBUG(10,("rap_jobid_delete: deleting jobid %u\n",
163 (unsigned int)jobid ));
165 rap_jobid = SVAL(data.dptr, 0);
166 SAFE_FREE(data.dptr);
167 SSVAL(buf,0,rap_jobid);
169 data.dsize = sizeof(rap_jobid);
170 tdb_delete(rap_tdb, key);
171 tdb_delete(rap_tdb, data);
174 static int get_queue_status(const char* sharename, print_status_struct *);
176 /****************************************************************************
177 Initialise the printing backend. Called once at startup before the fork().
178 ****************************************************************************/
180 bool print_backend_init(struct messaging_context *msg_ctx)
182 const char *sversion = "INFO/version";
183 int services = lp_numservices();
186 unlink(cache_path("printing.tdb"));
187 mkdir(cache_path("printing"),0755);
189 /* handle a Samba upgrade */
191 for (snum = 0; snum < services; snum++) {
192 struct tdb_print_db *pdb;
193 if (!lp_print_ok(snum))
196 pdb = get_print_db_byname(lp_const_servicename(snum));
199 if (tdb_lock_bystring(pdb->tdb, sversion) == -1) {
200 DEBUG(0,("print_backend_init: Failed to open printer %s database\n", lp_const_servicename(snum) ));
201 release_print_db(pdb);
204 if (tdb_fetch_int32(pdb->tdb, sversion) != PRINT_DATABASE_VERSION) {
205 tdb_wipe_all(pdb->tdb);
206 tdb_store_int32(pdb->tdb, sversion, PRINT_DATABASE_VERSION);
208 tdb_unlock_bystring(pdb->tdb, sversion);
209 release_print_db(pdb);
212 close_all_print_db(); /* Don't leave any open. */
214 /* do NT print initialization... */
215 return nt_printing_init(msg_ctx);
218 /****************************************************************************
219 Shut down printing backend. Called once at shutdown to close the tdb.
220 ****************************************************************************/
222 void printing_end(void)
224 close_all_print_db(); /* Don't leave any open. */
227 /****************************************************************************
228 Retrieve the set of printing functions for a given service. This allows
229 us to set the printer function table based on the value of the 'printing'
232 Use the generic interface as the default and only use cups interface only
233 when asked for (and only when supported)
234 ****************************************************************************/
236 static struct printif *get_printer_fns_from_type( enum printing_types type )
238 struct printif *printer_fns = &generic_printif;
241 if ( type == PRINT_CUPS ) {
242 printer_fns = &cups_printif;
244 #endif /* HAVE_CUPS */
247 if ( type == PRINT_IPRINT ) {
248 printer_fns = &iprint_printif;
250 #endif /* HAVE_IPRINT */
252 printer_fns->type = type;
257 static struct printif *get_printer_fns( int snum )
259 return get_printer_fns_from_type( (enum printing_types)lp_printing(snum) );
263 /****************************************************************************
264 Useful function to generate a tdb key.
265 ****************************************************************************/
267 static TDB_DATA print_key(uint32 jobid, uint32 *tmp)
271 SIVAL(tmp, 0, jobid);
272 ret.dptr = (uint8 *)tmp;
273 ret.dsize = sizeof(*tmp);
277 /***********************************************************************
278 unpack a pjob from a tdb buffer
279 ***********************************************************************/
281 int unpack_pjob( uint8 *buf, int buflen, struct printjob *pjob )
285 uint32 pjpid, pjsysjob, pjfd, pjstarttime, pjstatus;
286 uint32 pjsize, pjpage_count, pjspooled, pjsmbjob;
291 len += tdb_unpack(buf+len, buflen-len, "dddddddddffff",
309 if ( (used = unpack_devicemode(&pjob->nt_devmode, buf+len, buflen-len)) == -1 )
315 pjob->sysjob = pjsysjob;
317 pjob->starttime = pjstarttime;
318 pjob->status = pjstatus;
320 pjob->page_count = pjpage_count;
321 pjob->spooled = pjspooled;
322 pjob->smbjob = pjsmbjob;
328 /****************************************************************************
329 Useful function to find a print job in the database.
330 ****************************************************************************/
332 static struct printjob *print_job_find(const char *sharename, uint32 jobid)
334 static struct printjob pjob;
337 struct tdb_print_db *pdb = get_print_db_byname(sharename);
339 DEBUG(10,("print_job_find: looking up job %u for share %s\n",
340 (unsigned int)jobid, sharename ));
346 ret = tdb_fetch(pdb->tdb, print_key(jobid, &tmp));
347 release_print_db(pdb);
350 DEBUG(10,("print_job_find: failed to find jobid %u.\n", (unsigned int)jobid ));
354 if ( pjob.nt_devmode ) {
355 free_nt_devicemode( &pjob.nt_devmode );
360 if ( unpack_pjob( ret.dptr, ret.dsize, &pjob ) == -1 ) {
361 DEBUG(10,("print_job_find: failed to unpack jobid %u.\n", (unsigned int)jobid ));
368 DEBUG(10,("print_job_find: returning system job %d for jobid %u.\n",
369 (int)pjob.sysjob, (unsigned int)jobid ));
374 /* Convert a unix jobid to a smb jobid */
376 struct unixjob_traverse_state {
378 uint32 sysjob_to_jobid_value;
381 static int unixjob_traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA key,
382 TDB_DATA data, void *private_data)
384 struct printjob *pjob;
385 struct unixjob_traverse_state *state =
386 (struct unixjob_traverse_state *)private_data;
388 if (!data.dptr || data.dsize == 0)
391 pjob = (struct printjob *)data.dptr;
392 if (key.dsize != sizeof(uint32))
395 if (state->sysjob == pjob->sysjob) {
396 uint32 jobid = IVAL(key.dptr,0);
398 state->sysjob_to_jobid_value = jobid;
405 /****************************************************************************
406 This is a *horribly expensive call as we have to iterate through all the
407 current printer tdb's. Don't do this often ! JRA.
408 ****************************************************************************/
410 uint32 sysjob_to_jobid(int unix_jobid)
412 int services = lp_numservices();
414 struct unixjob_traverse_state state;
416 state.sysjob = unix_jobid;
417 state.sysjob_to_jobid_value = (uint32)-1;
419 for (snum = 0; snum < services; snum++) {
420 struct tdb_print_db *pdb;
421 if (!lp_print_ok(snum))
423 pdb = get_print_db_byname(lp_const_servicename(snum));
427 tdb_traverse(pdb->tdb, unixjob_traverse_fn, &state);
428 release_print_db(pdb);
429 if (state.sysjob_to_jobid_value != (uint32)-1)
430 return state.sysjob_to_jobid_value;
435 /****************************************************************************
436 Send notifications based on what has changed after a pjob_store.
437 ****************************************************************************/
439 static const struct {
441 uint32 spoolss_status;
442 } lpq_to_spoolss_status_map[] = {
443 { LPQ_QUEUED, JOB_STATUS_QUEUED },
444 { LPQ_PAUSED, JOB_STATUS_PAUSED },
445 { LPQ_SPOOLING, JOB_STATUS_SPOOLING },
446 { LPQ_PRINTING, JOB_STATUS_PRINTING },
447 { LPQ_DELETING, JOB_STATUS_DELETING },
448 { LPQ_OFFLINE, JOB_STATUS_OFFLINE },
449 { LPQ_PAPEROUT, JOB_STATUS_PAPEROUT },
450 { LPQ_PRINTED, JOB_STATUS_PRINTED },
451 { LPQ_DELETED, JOB_STATUS_DELETED },
452 { LPQ_BLOCKED, JOB_STATUS_BLOCKED_DEVQ },
453 { LPQ_USER_INTERVENTION, JOB_STATUS_USER_INTERVENTION },
457 /* Convert a lpq status value stored in printing.tdb into the
458 appropriate win32 API constant. */
460 static uint32 map_to_spoolss_status(uint32 lpq_status)
464 while (lpq_to_spoolss_status_map[i].lpq_status != -1) {
465 if (lpq_to_spoolss_status_map[i].lpq_status == lpq_status)
466 return lpq_to_spoolss_status_map[i].spoolss_status;
473 static void pjob_store_notify(const char* sharename, uint32 jobid, struct printjob *old_data,
474 struct printjob *new_data)
476 bool new_job = False;
481 /* Job attributes that can't be changed. We only send
482 notification for these on a new job. */
484 /* ACHTUNG! Due to a bug in Samba's spoolss parsing of the
485 NOTIFY_INFO_DATA buffer, we *have* to send the job submission
486 time first or else we'll end up with potential alignment
487 errors. I don't think the systemtime should be spooled as
488 a string, but this gets us around that error.
489 --jerry (i'll feel dirty for this) */
492 notify_job_submitted(sharename, jobid, new_data->starttime);
493 notify_job_username(sharename, jobid, new_data->user);
496 if (new_job || !strequal(old_data->jobname, new_data->jobname))
497 notify_job_name(sharename, jobid, new_data->jobname);
499 /* Job attributes of a new job or attributes that can be
502 if (new_job || !strequal(old_data->jobname, new_data->jobname))
503 notify_job_name(sharename, jobid, new_data->jobname);
505 if (new_job || old_data->status != new_data->status)
506 notify_job_status(sharename, jobid, map_to_spoolss_status(new_data->status));
508 if (new_job || old_data->size != new_data->size)
509 notify_job_total_bytes(sharename, jobid, new_data->size);
511 if (new_job || old_data->page_count != new_data->page_count)
512 notify_job_total_pages(sharename, jobid, new_data->page_count);
515 /****************************************************************************
516 Store a job structure back to the database.
517 ****************************************************************************/
519 static bool pjob_store(const char* sharename, uint32 jobid, struct printjob *pjob)
522 TDB_DATA old_data, new_data;
524 struct tdb_print_db *pdb = get_print_db_byname(sharename);
526 int len, newlen, buflen;
534 old_data = tdb_fetch(pdb->tdb, print_key(jobid, &tmp));
536 /* Doh! Now we have to pack/unpack data since the NT_DEVICEMODE was added */
543 len += tdb_pack(buf+len, buflen-len, "dddddddddffff",
545 (uint32)pjob->sysjob,
547 (uint32)pjob->starttime,
548 (uint32)pjob->status,
550 (uint32)pjob->page_count,
551 (uint32)pjob->spooled,
552 (uint32)pjob->smbjob,
558 len += pack_devicemode(pjob->nt_devmode, buf+len, buflen-len);
561 buf = (uint8 *)SMB_REALLOC(buf, len);
563 DEBUG(0,("pjob_store: failed to enlarge buffer!\n"));
568 } while ( buflen != len );
574 new_data.dsize = len;
575 ret = (tdb_store(pdb->tdb, print_key(jobid, &tmp), new_data,
578 release_print_db(pdb);
580 /* Send notify updates for what has changed */
583 struct printjob old_pjob;
585 if ( old_data.dsize )
587 if ( unpack_pjob( old_data.dptr, old_data.dsize, &old_pjob ) != -1 )
589 pjob_store_notify( sharename, jobid, &old_pjob , pjob );
590 free_nt_devicemode( &old_pjob.nt_devmode );
595 pjob_store_notify( sharename, jobid, NULL, pjob );
600 SAFE_FREE( old_data.dptr );
606 /****************************************************************************
607 Remove a job structure from the database.
608 ****************************************************************************/
610 void pjob_delete(const char* sharename, uint32 jobid)
613 struct printjob *pjob;
614 uint32 job_status = 0;
615 struct tdb_print_db *pdb;
617 pdb = get_print_db_byname( sharename );
622 pjob = print_job_find( sharename, jobid );
625 DEBUG(5, ("pjob_delete: we were asked to delete nonexistent job %u\n",
626 (unsigned int)jobid));
627 release_print_db(pdb);
631 /* We must cycle through JOB_STATUS_DELETING and
632 JOB_STATUS_DELETED for the port monitor to delete the job
635 job_status = JOB_STATUS_DELETING|JOB_STATUS_DELETED;
636 notify_job_status(sharename, jobid, job_status);
638 /* Remove from printing.tdb */
640 tdb_delete(pdb->tdb, print_key(jobid, &tmp));
641 remove_from_jobs_changed(sharename, jobid);
642 release_print_db( pdb );
643 rap_jobid_delete(sharename, jobid);
646 /****************************************************************************
647 List a unix job in the print database.
648 ****************************************************************************/
650 static void print_unix_job(const char *sharename, print_queue_struct *q, uint32 jobid)
652 struct printjob pj, *old_pj;
654 if (jobid == (uint32)-1)
655 jobid = q->job + UNIX_JOB_START;
657 /* Preserve the timestamp on an existing unix print job */
659 old_pj = print_job_find(sharename, jobid);
666 pj.starttime = old_pj ? old_pj->starttime : q->time;
667 pj.status = q->status;
670 fstrcpy(pj.filename, old_pj ? old_pj->filename : "");
671 if (jobid < UNIX_JOB_START) {
673 fstrcpy(pj.jobname, old_pj ? old_pj->jobname : "Remote Downlevel Document");
676 fstrcpy(pj.jobname, old_pj ? old_pj->jobname : q->fs_file);
678 fstrcpy(pj.user, old_pj ? old_pj->user : q->fs_user);
679 fstrcpy(pj.queuename, old_pj ? old_pj->queuename : sharename );
681 pjob_store(sharename, jobid, &pj);
685 struct traverse_struct {
686 print_queue_struct *queue;
687 int qcount, snum, maxcount, total_jobs;
688 const char *sharename;
690 const char *lprm_command;
691 struct printif *print_if;
694 /****************************************************************************
695 Utility fn to delete any jobs that are no longer active.
696 ****************************************************************************/
698 static int traverse_fn_delete(TDB_CONTEXT *t, TDB_DATA key, TDB_DATA data, void *state)
700 struct traverse_struct *ts = (struct traverse_struct *)state;
701 struct printjob pjob;
705 if ( key.dsize != sizeof(jobid) )
708 jobid = IVAL(key.dptr, 0);
709 if ( unpack_pjob( data.dptr, data.dsize, &pjob ) == -1 )
711 free_nt_devicemode( &pjob.nt_devmode );
715 /* remove a unix job if it isn't in the system queue any more */
717 for (i=0;i<ts->qcount;i++) {
718 uint32 u_jobid = (ts->queue[i].job + UNIX_JOB_START);
719 if (jobid == u_jobid)
722 if (i == ts->qcount) {
723 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !smbjob\n",
724 (unsigned int)jobid ));
725 pjob_delete(ts->sharename, jobid);
729 /* need to continue the the bottom of the function to
730 save the correct attributes */
733 /* maybe it hasn't been spooled yet */
735 /* if a job is not spooled and the process doesn't
736 exist then kill it. This cleans up after smbd
738 if (!process_exists_by_pid(pjob.pid)) {
739 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !process_exists (%u)\n",
740 (unsigned int)jobid, (unsigned int)pjob.pid ));
741 pjob_delete(ts->sharename, jobid);
747 /* this check only makes sense for jobs submitted from Windows clients */
750 for (i=0;i<ts->qcount;i++) {
753 if ( pjob.status == LPQ_DELETED )
756 curr_jobid = print_parse_jobid(ts->queue[i].fs_file);
758 if (jobid == curr_jobid) {
760 /* try to clean up any jobs that need to be deleted */
762 if ( pjob.status == LPQ_DELETING ) {
765 result = (*(ts->print_if->job_delete))(
766 ts->sharename, ts->lprm_command, &pjob );
769 /* if we can't delete, then reset the job status */
770 pjob.status = LPQ_QUEUED;
771 pjob_store(ts->sharename, jobid, &pjob);
774 /* if we deleted the job, the remove the tdb record */
775 pjob_delete(ts->sharename, jobid);
776 pjob.status = LPQ_DELETED;
786 /* The job isn't in the system queue - we have to assume it has
787 completed, so delete the database entry. */
789 if (i == ts->qcount) {
791 /* A race can occur between the time a job is spooled and
792 when it appears in the lpq output. This happens when
793 the job is added to printing.tdb when another smbd
794 running print_queue_update() has completed a lpq and
795 is currently traversing the printing tdb and deleting jobs.
796 Don't delete the job if it was submitted after the lpq_time. */
798 if (pjob.starttime < ts->lpq_time) {
799 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to pjob.starttime (%u) < ts->lpq_time (%u)\n",
801 (unsigned int)pjob.starttime,
802 (unsigned int)ts->lpq_time ));
803 pjob_delete(ts->sharename, jobid);
809 /* Save the pjob attributes we will store.
810 FIXME!!! This is the only place where queue->job
811 represents the SMB jobid --jerry */
813 ts->queue[i].job = jobid;
814 ts->queue[i].size = pjob.size;
815 ts->queue[i].page_count = pjob.page_count;
816 ts->queue[i].status = pjob.status;
817 ts->queue[i].priority = 1;
818 ts->queue[i].time = pjob.starttime;
819 fstrcpy(ts->queue[i].fs_user, pjob.user);
820 fstrcpy(ts->queue[i].fs_file, pjob.jobname);
827 /****************************************************************************
828 Check if the print queue has been updated recently enough.
829 ****************************************************************************/
831 static void print_cache_flush(const char *sharename)
834 struct tdb_print_db *pdb = get_print_db_byname(sharename);
838 slprintf(key, sizeof(key)-1, "CACHE/%s", sharename);
839 tdb_store_int32(pdb->tdb, key, -1);
840 release_print_db(pdb);
843 /****************************************************************************
844 Check if someone already thinks they are doing the update.
845 ****************************************************************************/
847 static pid_t get_updating_pid(const char *sharename)
852 struct tdb_print_db *pdb = get_print_db_byname(sharename);
856 slprintf(keystr, sizeof(keystr)-1, "UPDATING/%s", sharename);
857 key = string_tdb_data(keystr);
859 data = tdb_fetch(pdb->tdb, key);
860 release_print_db(pdb);
861 if (!data.dptr || data.dsize != sizeof(pid_t)) {
862 SAFE_FREE(data.dptr);
866 updating_pid = IVAL(data.dptr, 0);
867 SAFE_FREE(data.dptr);
869 if (process_exists_by_pid(updating_pid))
875 /****************************************************************************
876 Set the fact that we're doing the update, or have finished doing the update
878 ****************************************************************************/
880 static void set_updating_pid(const fstring sharename, bool updating)
885 pid_t updating_pid = sys_getpid();
888 struct tdb_print_db *pdb = get_print_db_byname(sharename);
893 slprintf(keystr, sizeof(keystr)-1, "UPDATING/%s", sharename);
894 key = string_tdb_data(keystr);
896 DEBUG(5, ("set_updating_pid: %s updating lpq cache for print share %s\n",
897 updating ? "" : "not ",
901 tdb_delete(pdb->tdb, key);
902 release_print_db(pdb);
906 SIVAL( buffer, 0, updating_pid);
908 data.dsize = 4; /* we always assume this is a 4 byte value */
910 tdb_store(pdb->tdb, key, data, TDB_REPLACE);
911 release_print_db(pdb);
914 /****************************************************************************
915 Sort print jobs by submittal time.
916 ****************************************************************************/
918 static int printjob_comp(print_queue_struct *j1, print_queue_struct *j2)
929 /* Sort on job start time */
931 if (j1->time == j2->time)
933 return (j1->time > j2->time) ? 1 : -1;
936 /****************************************************************************
937 Store the sorted queue representation for later portmon retrieval.
939 ****************************************************************************/
941 static void store_queue_struct(struct tdb_print_db *pdb, struct traverse_struct *pts)
944 int max_reported_jobs = lp_max_reported_jobs(pts->snum);
945 print_queue_struct *queue = pts->queue;
950 if (max_reported_jobs && (max_reported_jobs < pts->qcount))
951 pts->qcount = max_reported_jobs;
954 /* Work out the size. */
956 data.dsize += tdb_pack(NULL, 0, "d", qcount);
958 for (i = 0; i < pts->qcount; i++) {
959 if ( queue[i].status == LPQ_DELETED )
963 data.dsize += tdb_pack(NULL, 0, "ddddddff",
964 (uint32)queue[i].job,
965 (uint32)queue[i].size,
966 (uint32)queue[i].page_count,
967 (uint32)queue[i].status,
968 (uint32)queue[i].priority,
969 (uint32)queue[i].time,
974 if ((data.dptr = (uint8 *)SMB_MALLOC(data.dsize)) == NULL)
978 len += tdb_pack(data.dptr + len, data.dsize - len, "d", qcount);
979 for (i = 0; i < pts->qcount; i++) {
980 if ( queue[i].status == LPQ_DELETED )
983 len += tdb_pack(data.dptr + len, data.dsize - len, "ddddddff",
984 (uint32)queue[i].job,
985 (uint32)queue[i].size,
986 (uint32)queue[i].page_count,
987 (uint32)queue[i].status,
988 (uint32)queue[i].priority,
989 (uint32)queue[i].time,
994 tdb_store(pdb->tdb, string_tdb_data("INFO/linear_queue_array"), data,
996 SAFE_FREE(data.dptr);
1000 static TDB_DATA get_jobs_changed_data(struct tdb_print_db *pdb)
1006 data = tdb_fetch(pdb->tdb, string_tdb_data("INFO/jobs_changed"));
1007 if (data.dptr == NULL || data.dsize == 0 || (data.dsize % 4 != 0)) {
1008 SAFE_FREE(data.dptr);
1015 static void check_job_changed(const char *sharename, TDB_DATA data, uint32 jobid)
1018 unsigned int job_count = data.dsize / 4;
1020 for (i = 0; i < job_count; i++) {
1023 ch_jobid = IVAL(data.dptr, i*4);
1024 if (ch_jobid == jobid)
1025 remove_from_jobs_changed(sharename, jobid);
1029 /****************************************************************************
1030 Check if the print queue has been updated recently enough.
1031 ****************************************************************************/
1033 static bool print_cache_expired(const char *sharename, bool check_pending)
1036 time_t last_qscan_time, time_now = time(NULL);
1037 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1038 bool result = False;
1043 snprintf(key, sizeof(key), "CACHE/%s", sharename);
1044 last_qscan_time = (time_t)tdb_fetch_int32(pdb->tdb, key);
1047 * Invalidate the queue for 3 reasons.
1048 * (1). last queue scan time == -1.
1049 * (2). Current time - last queue scan time > allowed cache time.
1050 * (3). last queue scan time > current time + MAX_CACHE_VALID_TIME (1 hour by default).
1051 * This last test picks up machines for which the clock has been moved
1052 * forward, an lpq scan done and then the clock moved back. Otherwise
1053 * that last lpq scan would stay around for a loooong loooong time... :-). JRA.
1056 if (last_qscan_time == ((time_t)-1)
1057 || (time_now - last_qscan_time) >= lp_lpqcachetime()
1058 || last_qscan_time > (time_now + MAX_CACHE_VALID_TIME))
1061 time_t msg_pending_time;
1063 DEBUG(4, ("print_cache_expired: cache expired for queue %s "
1064 "(last_qscan_time = %d, time now = %d, qcachetime = %d)\n",
1065 sharename, (int)last_qscan_time, (int)time_now,
1066 (int)lp_lpqcachetime() ));
1068 /* check if another smbd has already sent a message to update the
1069 queue. Give the pending message one minute to clear and
1070 then send another message anyways. Make sure to check for
1071 clocks that have been run forward and then back again. */
1073 snprintf(key, sizeof(key), "MSG_PENDING/%s", sharename);
1076 && tdb_fetch_uint32( pdb->tdb, key, &u )
1077 && (msg_pending_time=u) > 0
1078 && msg_pending_time <= time_now
1079 && (time_now - msg_pending_time) < 60 )
1081 DEBUG(4,("print_cache_expired: message already pending for %s. Accepting cache\n",
1090 release_print_db(pdb);
1094 /****************************************************************************
1095 main work for updating the lpq cahe for a printer queue
1096 ****************************************************************************/
1098 static void print_queue_update_internal( const char *sharename,
1099 struct printif *current_printif,
1100 char *lpq_command, char *lprm_command )
1103 print_queue_struct *queue = NULL;
1104 print_status_struct status;
1105 print_status_struct old_status;
1106 struct printjob *pjob;
1107 struct traverse_struct tstruct;
1110 fstring keystr, cachestr;
1111 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1117 DEBUG(5,("print_queue_update_internal: printer = %s, type = %d, lpq command = [%s]\n",
1118 sharename, current_printif->type, lpq_command));
1121 * Update the cache time FIRST ! Stops others even
1122 * attempting to get the lock and doing this
1123 * if the lpq takes a long time.
1126 slprintf(cachestr, sizeof(cachestr)-1, "CACHE/%s", sharename);
1127 tdb_store_int32(pdb->tdb, cachestr, (int)time(NULL));
1129 /* get the current queue using the appropriate interface */
1130 ZERO_STRUCT(status);
1132 qcount = (*(current_printif->queue_get))(sharename,
1133 current_printif->type,
1134 lpq_command, &queue, &status);
1136 DEBUG(3, ("print_queue_update_internal: %d job%s in queue for %s\n",
1137 qcount, (qcount != 1) ? "s" : "", sharename));
1139 /* Sort the queue by submission time otherwise they are displayed
1142 TYPESAFE_QSORT(queue, qcount, printjob_comp);
1145 any job in the internal database that is marked as spooled
1146 and doesn't exist in the system queue is considered finished
1147 and removed from the database
1149 any job in the system database but not in the internal database
1150 is added as a unix job
1152 fill in any system job numbers as we go
1155 jcdata = get_jobs_changed_data(pdb);
1157 for (i=0; i<qcount; i++) {
1158 uint32 jobid = print_parse_jobid(queue[i].fs_file);
1160 if (jobid == (uint32)-1) {
1161 /* assume its a unix print job */
1162 print_unix_job(sharename, &queue[i], jobid);
1166 /* we have an active SMB print job - update its status */
1167 pjob = print_job_find(sharename, jobid);
1169 /* err, somethings wrong. Probably smbd was restarted
1170 with jobs in the queue. All we can do is treat them
1171 like unix jobs. Pity. */
1172 print_unix_job(sharename, &queue[i], jobid);
1176 pjob->sysjob = queue[i].job;
1178 /* don't reset the status on jobs to be deleted */
1180 if ( pjob->status != LPQ_DELETING )
1181 pjob->status = queue[i].status;
1183 pjob_store(sharename, jobid, pjob);
1185 check_job_changed(sharename, jcdata, jobid);
1188 SAFE_FREE(jcdata.dptr);
1190 /* now delete any queued entries that don't appear in the
1192 tstruct.queue = queue;
1193 tstruct.qcount = qcount;
1195 tstruct.total_jobs = 0;
1196 tstruct.lpq_time = time(NULL);
1197 tstruct.sharename = sharename;
1198 tstruct.lprm_command = lprm_command;
1199 tstruct.print_if = current_printif;
1201 tdb_traverse(pdb->tdb, traverse_fn_delete, (void *)&tstruct);
1203 /* Store the linearised queue, max jobs only. */
1204 store_queue_struct(pdb, &tstruct);
1206 SAFE_FREE(tstruct.queue);
1208 DEBUG(10,("print_queue_update_internal: printer %s INFO/total_jobs = %d\n",
1209 sharename, tstruct.total_jobs ));
1211 tdb_store_int32(pdb->tdb, "INFO/total_jobs", tstruct.total_jobs);
1213 get_queue_status(sharename, &old_status);
1214 if (old_status.qcount != qcount)
1215 DEBUG(10,("print_queue_update_internal: queue status change %d jobs -> %d jobs for printer %s\n",
1216 old_status.qcount, qcount, sharename));
1218 /* store the new queue status structure */
1219 slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", sharename);
1220 key = string_tdb_data(keystr);
1222 status.qcount = qcount;
1223 data.dptr = (uint8 *)&status;
1224 data.dsize = sizeof(status);
1225 tdb_store(pdb->tdb, key, data, TDB_REPLACE);
1228 * Update the cache time again. We want to do this call
1229 * as little as possible...
1232 slprintf(keystr, sizeof(keystr)-1, "CACHE/%s", sharename);
1233 tdb_store_int32(pdb->tdb, keystr, (int32)time(NULL));
1235 /* clear the msg pending record for this queue */
1237 snprintf(keystr, sizeof(keystr), "MSG_PENDING/%s", sharename);
1239 if ( !tdb_store_uint32( pdb->tdb, keystr, 0 ) ) {
1240 /* log a message but continue on */
1242 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1246 release_print_db( pdb );
1251 /****************************************************************************
1252 Update the internal database from the system print queue for a queue.
1253 obtain a lock on the print queue before proceeding (needed when mutiple
1254 smbd processes maytry to update the lpq cache concurrently).
1255 ****************************************************************************/
1257 static void print_queue_update_with_lock( const char *sharename,
1258 struct printif *current_printif,
1259 char *lpq_command, char *lprm_command )
1262 struct tdb_print_db *pdb;
1264 DEBUG(5,("print_queue_update_with_lock: printer share = %s\n", sharename));
1265 pdb = get_print_db_byname(sharename);
1269 if ( !print_cache_expired(sharename, False) ) {
1270 DEBUG(5,("print_queue_update_with_lock: print cache for %s is still ok\n", sharename));
1271 release_print_db(pdb);
1276 * Check to see if someone else is doing this update.
1277 * This is essentially a mutex on the update.
1280 if (get_updating_pid(sharename) != -1) {
1281 release_print_db(pdb);
1285 /* Lock the queue for the database update */
1287 slprintf(keystr, sizeof(keystr) - 1, "LOCK/%s", sharename);
1288 /* Only wait 10 seconds for this. */
1289 if (tdb_lock_bystring_with_timeout(pdb->tdb, keystr, 10) == -1) {
1290 DEBUG(0,("print_queue_update_with_lock: Failed to lock printer %s database\n", sharename));
1291 release_print_db(pdb);
1296 * Ensure that no one else got in here.
1297 * If the updating pid is still -1 then we are
1301 if (get_updating_pid(sharename) != -1) {
1303 * Someone else is doing the update, exit.
1305 tdb_unlock_bystring(pdb->tdb, keystr);
1306 release_print_db(pdb);
1311 * We're going to do the update ourselves.
1314 /* Tell others we're doing the update. */
1315 set_updating_pid(sharename, True);
1318 * Allow others to enter and notice we're doing
1322 tdb_unlock_bystring(pdb->tdb, keystr);
1324 /* do the main work now */
1326 print_queue_update_internal( sharename, current_printif,
1327 lpq_command, lprm_command );
1329 /* Delete our pid from the db. */
1330 set_updating_pid(sharename, False);
1331 release_print_db(pdb);
1334 /****************************************************************************
1335 this is the receive function of the background lpq updater
1336 ****************************************************************************/
1337 static void print_queue_receive(struct messaging_context *msg,
1340 struct server_id server_id,
1344 char *lpqcommand = NULL, *lprmcommand = NULL;
1348 len = tdb_unpack( (uint8 *)data->data, data->length, "fdPP",
1355 SAFE_FREE(lpqcommand);
1356 SAFE_FREE(lprmcommand);
1357 DEBUG(0,("print_queue_receive: Got invalid print queue update message\n"));
1361 print_queue_update_with_lock(sharename,
1362 get_printer_fns_from_type((enum printing_types)printing_type),
1363 lpqcommand, lprmcommand );
1365 SAFE_FREE(lpqcommand);
1366 SAFE_FREE(lprmcommand);
1370 static void printing_pause_fd_handler(struct tevent_context *ev,
1371 struct tevent_fd *fde,
1376 * If pause_pipe[1] is closed it means the parent smbd
1377 * and children exited or aborted.
1379 exit_server_cleanly(NULL);
1382 static void add_child_pid(pid_t pid)
1384 extern struct child_pid *children;
1385 struct child_pid *child;
1386 extern int num_children;
1388 child = SMB_MALLOC_P(struct child_pid);
1389 if (child == NULL) {
1390 DEBUG(0, ("Could not add child struct -- malloc failed\n"));
1394 DLIST_ADD(children, child);
1398 static pid_t background_lpq_updater_pid = -1;
1400 /****************************************************************************
1401 main thread of the background lpq updater
1402 ****************************************************************************/
1403 void start_background_queue(void)
1405 /* Use local variables for this as we don't
1406 * need to save the parent side of this, just
1407 * ensure it closes when the process exits.
1411 DEBUG(3,("start_background_queue: Starting background LPQ thread\n"));
1413 if (pipe(pause_pipe) == -1) {
1414 DEBUG(5,("start_background_queue: cannot create pipe. %s\n", strerror(errno) ));
1418 background_lpq_updater_pid = sys_fork();
1420 if (background_lpq_updater_pid == -1) {
1421 DEBUG(5,("start_background_queue: background LPQ thread failed to start. %s\n", strerror(errno) ));
1425 /* Track the printing pid along with other smbd children */
1426 add_child_pid(background_lpq_updater_pid);
1428 if(background_lpq_updater_pid == 0) {
1429 struct tevent_fd *fde;
1433 DEBUG(5,("start_background_queue: background LPQ thread started\n"));
1435 close(pause_pipe[0]);
1438 if (!NT_STATUS_IS_OK(reinit_after_fork(smbd_messaging_context(),
1439 smbd_event_context(),
1441 DEBUG(0,("reinit_after_fork() failed\n"));
1442 smb_panic("reinit_after_fork() failed");
1445 smbd_setup_sig_term_handler();
1446 smbd_setup_sig_hup_handler();
1448 if (!serverid_register_self(FLAG_MSG_GENERAL|FLAG_MSG_SMBD
1449 |FLAG_MSG_PRINT_GENERAL)) {
1453 if (!locking_init()) {
1457 messaging_register(smbd_messaging_context(), NULL,
1458 MSG_PRINTER_UPDATE, print_queue_receive);
1460 fde = tevent_add_fd(smbd_event_context(), smbd_event_context(),
1461 pause_pipe[1], TEVENT_FD_READ,
1462 printing_pause_fd_handler,
1465 DEBUG(0,("tevent_add_fd() failed for pause_pipe\n"));
1466 smb_panic("tevent_add_fd() failed for pause_pipe");
1469 DEBUG(5,("start_background_queue: background LPQ thread waiting for messages\n"));
1470 ret = tevent_loop_wait(smbd_event_context());
1471 /* should not be reached */
1472 DEBUG(0,("background_queue: tevent_loop_wait() exited with %d - %s\n",
1473 ret, (ret == 0) ? "out of events" : strerror(errno)));
1477 close(pause_pipe[1]);
1480 /****************************************************************************
1481 update the internal database from the system print queue for a queue
1482 ****************************************************************************/
1484 static void print_queue_update(int snum, bool force)
1488 char *lpqcommand = NULL;
1489 char *lprmcommand = NULL;
1490 uint8 *buffer = NULL;
1493 struct tdb_print_db *pdb;
1495 struct printif *current_printif;
1496 TALLOC_CTX *ctx = talloc_tos();
1498 fstrcpy( sharename, lp_const_servicename(snum));
1500 /* don't strip out characters like '$' from the printername */
1502 lpqcommand = talloc_string_sub2(ctx,
1503 lp_lpqcommand(snum),
1506 false, false, false);
1510 lpqcommand = talloc_sub_advanced(ctx,
1511 lp_servicename(snum),
1512 current_user_info.unix_name,
1514 current_user.ut.gid,
1515 get_current_username(),
1516 current_user_info.domain,
1522 lprmcommand = talloc_string_sub2(ctx,
1523 lp_lprmcommand(snum),
1526 false, false, false);
1530 lprmcommand = talloc_sub_advanced(ctx,
1531 lp_servicename(snum),
1532 current_user_info.unix_name,
1534 current_user.ut.gid,
1535 get_current_username(),
1536 current_user_info.domain,
1543 * Make sure that the background queue process exists.
1544 * Otherwise just do the update ourselves
1547 if ( force || background_lpq_updater_pid == -1 ) {
1548 DEBUG(4,("print_queue_update: updating queue [%s] myself\n", sharename));
1549 current_printif = get_printer_fns( snum );
1550 print_queue_update_with_lock( sharename, current_printif, lpqcommand, lprmcommand );
1555 type = lp_printing(snum);
1557 /* get the length */
1559 len = tdb_pack( NULL, 0, "fdPP",
1565 buffer = SMB_XMALLOC_ARRAY( uint8, len );
1567 /* now pack the buffer */
1568 newlen = tdb_pack( buffer, len, "fdPP",
1574 SMB_ASSERT( newlen == len );
1576 DEBUG(10,("print_queue_update: Sending message -> printer = %s, "
1577 "type = %d, lpq command = [%s] lprm command = [%s]\n",
1578 sharename, type, lpqcommand, lprmcommand ));
1580 /* here we set a msg pending record for other smbd processes
1581 to throttle the number of duplicate print_queue_update msgs
1584 pdb = get_print_db_byname(sharename);
1590 snprintf(key, sizeof(key), "MSG_PENDING/%s", sharename);
1592 if ( !tdb_store_uint32( pdb->tdb, key, time(NULL) ) ) {
1593 /* log a message but continue on */
1595 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1599 release_print_db( pdb );
1601 /* finally send the message */
1603 messaging_send_buf(smbd_messaging_context(),
1604 pid_to_procid(background_lpq_updater_pid),
1605 MSG_PRINTER_UPDATE, (uint8 *)buffer, len);
1607 SAFE_FREE( buffer );
1612 /****************************************************************************
1613 Create/Update an entry in the print tdb that will allow us to send notify
1614 updates only to interested smbd's.
1615 ****************************************************************************/
1617 bool print_notify_register_pid(int snum)
1620 struct tdb_print_db *pdb = NULL;
1621 TDB_CONTEXT *tdb = NULL;
1622 const char *printername;
1623 uint32 mypid = (uint32)sys_getpid();
1627 /* if (snum == -1), then the change notify request was
1628 on a print server handle and we need to register on
1633 int num_services = lp_numservices();
1636 for ( idx=0; idx<num_services; idx++ ) {
1637 if (lp_snum_ok(idx) && lp_print_ok(idx) )
1638 print_notify_register_pid(idx);
1643 else /* register for a specific printer */
1645 printername = lp_const_servicename(snum);
1646 pdb = get_print_db_byname(printername);
1652 if (tdb_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) == -1) {
1653 DEBUG(0,("print_notify_register_pid: Failed to lock printer %s\n",
1656 release_print_db(pdb);
1660 data = get_printer_notify_pid_list( tdb, printername, True );
1662 /* Add ourselves and increase the refcount. */
1664 for (i = 0; i < data.dsize; i += 8) {
1665 if (IVAL(data.dptr,i) == mypid) {
1666 uint32 new_refcount = IVAL(data.dptr, i+4) + 1;
1667 SIVAL(data.dptr, i+4, new_refcount);
1672 if (i == data.dsize) {
1673 /* We weren't in the list. Realloc. */
1674 data.dptr = (uint8 *)SMB_REALLOC(data.dptr, data.dsize + 8);
1676 DEBUG(0,("print_notify_register_pid: Relloc fail for printer %s\n",
1681 SIVAL(data.dptr,data.dsize - 8,mypid);
1682 SIVAL(data.dptr,data.dsize - 4,1); /* Refcount. */
1685 /* Store back the record. */
1686 if (tdb_store_bystring(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) == -1) {
1687 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1688 list for printer %s\n", printername));
1696 tdb_unlock_bystring(tdb, NOTIFY_PID_LIST_KEY);
1698 release_print_db(pdb);
1699 SAFE_FREE(data.dptr);
1703 /****************************************************************************
1704 Update an entry in the print tdb that will allow us to send notify
1705 updates only to interested smbd's.
1706 ****************************************************************************/
1708 bool print_notify_deregister_pid(int snum)
1711 struct tdb_print_db *pdb = NULL;
1712 TDB_CONTEXT *tdb = NULL;
1713 const char *printername;
1714 uint32 mypid = (uint32)sys_getpid();
1718 /* if ( snum == -1 ), we are deregister a print server handle
1719 which means to deregister on all print queues */
1723 int num_services = lp_numservices();
1726 for ( idx=0; idx<num_services; idx++ ) {
1727 if ( lp_snum_ok(idx) && lp_print_ok(idx) )
1728 print_notify_deregister_pid(idx);
1733 else /* deregister a specific printer */
1735 printername = lp_const_servicename(snum);
1736 pdb = get_print_db_byname(printername);
1742 if (tdb_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) == -1) {
1743 DEBUG(0,("print_notify_register_pid: Failed to lock \
1744 printer %s database\n", printername));
1746 release_print_db(pdb);
1750 data = get_printer_notify_pid_list( tdb, printername, True );
1752 /* Reduce refcount. Remove ourselves if zero. */
1754 for (i = 0; i < data.dsize; ) {
1755 if (IVAL(data.dptr,i) == mypid) {
1756 uint32 refcount = IVAL(data.dptr, i+4);
1760 if (refcount == 0) {
1761 if (data.dsize - i > 8)
1762 memmove( &data.dptr[i], &data.dptr[i+8], data.dsize - i - 8);
1766 SIVAL(data.dptr, i+4, refcount);
1772 if (data.dsize == 0)
1773 SAFE_FREE(data.dptr);
1775 /* Store back the record. */
1776 if (tdb_store_bystring(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) == -1) {
1777 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1778 list for printer %s\n", printername));
1786 tdb_unlock_bystring(tdb, NOTIFY_PID_LIST_KEY);
1788 release_print_db(pdb);
1789 SAFE_FREE(data.dptr);
1793 /****************************************************************************
1794 Check if a jobid is valid. It is valid if it exists in the database.
1795 ****************************************************************************/
1797 bool print_job_exists(const char* sharename, uint32 jobid)
1799 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1805 ret = tdb_exists(pdb->tdb, print_key(jobid, &tmp));
1806 release_print_db(pdb);
1810 /****************************************************************************
1811 Give the fd used for a jobid.
1812 ****************************************************************************/
1814 int print_job_fd(const char* sharename, uint32 jobid)
1816 struct printjob *pjob = print_job_find(sharename, jobid);
1819 /* don't allow another process to get this info - it is meaningless */
1820 if (pjob->pid != sys_getpid())
1825 /****************************************************************************
1826 Give the filename used for a jobid.
1827 Only valid for the process doing the spooling and when the job
1828 has not been spooled.
1829 ****************************************************************************/
1831 char *print_job_fname(const char* sharename, uint32 jobid)
1833 struct printjob *pjob = print_job_find(sharename, jobid);
1834 if (!pjob || pjob->spooled || pjob->pid != sys_getpid())
1836 return pjob->filename;
1840 /****************************************************************************
1841 Give the filename used for a jobid.
1842 Only valid for the process doing the spooling and when the job
1843 has not been spooled.
1844 ****************************************************************************/
1846 NT_DEVICEMODE *print_job_devmode(const char* sharename, uint32 jobid)
1848 struct printjob *pjob = print_job_find(sharename, jobid);
1853 return pjob->nt_devmode;
1856 /****************************************************************************
1857 Set the name of a job. Only possible for owner.
1858 ****************************************************************************/
1860 bool print_job_set_name(const char *sharename, uint32 jobid, char *name)
1862 struct printjob *pjob;
1864 pjob = print_job_find(sharename, jobid);
1865 if (!pjob || pjob->pid != sys_getpid())
1868 fstrcpy(pjob->jobname, name);
1869 return pjob_store(sharename, jobid, pjob);
1872 /***************************************************************************
1873 Remove a jobid from the 'jobs changed' list.
1874 ***************************************************************************/
1876 static bool remove_from_jobs_changed(const char* sharename, uint32 jobid)
1878 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1880 size_t job_count, i;
1882 bool gotlock = False;
1890 key = string_tdb_data("INFO/jobs_changed");
1892 if (tdb_chainlock_with_timeout(pdb->tdb, key, 5) == -1)
1897 data = tdb_fetch(pdb->tdb, key);
1899 if (data.dptr == NULL || data.dsize == 0 || (data.dsize % 4 != 0))
1902 job_count = data.dsize / 4;
1903 for (i = 0; i < job_count; i++) {
1906 ch_jobid = IVAL(data.dptr, i*4);
1907 if (ch_jobid == jobid) {
1908 if (i < job_count -1 )
1909 memmove(data.dptr + (i*4), data.dptr + (i*4) + 4, (job_count - i - 1)*4 );
1911 if (tdb_store(pdb->tdb, key, data, TDB_REPLACE) == -1)
1921 tdb_chainunlock(pdb->tdb, key);
1922 SAFE_FREE(data.dptr);
1923 release_print_db(pdb);
1925 DEBUG(10,("remove_from_jobs_changed: removed jobid %u\n", (unsigned int)jobid ));
1927 DEBUG(10,("remove_from_jobs_changed: Failed to remove jobid %u\n", (unsigned int)jobid ));
1931 /****************************************************************************
1932 Delete a print job - don't update queue.
1933 ****************************************************************************/
1935 static bool print_job_delete1(int snum, uint32 jobid)
1937 const char* sharename = lp_const_servicename(snum);
1938 struct printjob *pjob = print_job_find(sharename, jobid);
1940 struct printif *current_printif = get_printer_fns( snum );
1946 * If already deleting just return.
1949 if (pjob->status == LPQ_DELETING)
1952 /* Hrm - we need to be able to cope with deleting a job before it
1953 has reached the spooler. Just mark it as LPQ_DELETING and
1954 let the print_queue_update() code rmeove the record */
1957 if (pjob->sysjob == -1) {
1958 DEBUG(5, ("attempt to delete job %u not seen by lpr\n", (unsigned int)jobid));
1961 /* Set the tdb entry to be deleting. */
1963 pjob->status = LPQ_DELETING;
1964 pjob_store(sharename, jobid, pjob);
1966 if (pjob->spooled && pjob->sysjob != -1)
1968 result = (*(current_printif->job_delete))(
1970 lp_lprmcommand(snum),
1973 /* Delete the tdb entry if the delete succeeded or the job hasn't
1977 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1982 pjob_delete(sharename, jobid);
1983 /* Ensure we keep a rough count of the number of total jobs... */
1984 tdb_change_int32_atomic(pdb->tdb, "INFO/total_jobs", &njobs, -1);
1985 release_print_db(pdb);
1989 remove_from_jobs_changed( sharename, jobid );
1991 return (result == 0);
1994 /****************************************************************************
1995 Return true if the current user owns the print job.
1996 ****************************************************************************/
1998 static bool is_owner(struct auth_serversupplied_info *server_info,
1999 const char *servicename,
2002 struct printjob *pjob = print_job_find(servicename, jobid);
2004 if (!pjob || !server_info)
2007 return strequal(pjob->user, server_info->sanitized_username);
2010 /****************************************************************************
2012 ****************************************************************************/
2014 bool print_job_delete(struct auth_serversupplied_info *server_info, int snum,
2015 uint32 jobid, WERROR *errcode)
2017 const char* sharename = lp_const_servicename( snum );
2018 struct printjob *pjob;
2024 owner = is_owner(server_info, lp_const_servicename(snum), jobid);
2026 /* Check access against security descriptor or whether the user
2030 !print_access_check(server_info, snum, JOB_ACCESS_ADMINISTER)) {
2031 DEBUG(3, ("delete denied by security descriptor\n"));
2032 *errcode = WERR_ACCESS_DENIED;
2034 /* BEGIN_ADMIN_LOG */
2035 sys_adminlog( LOG_ERR,
2036 "Permission denied-- user not allowed to delete, \
2037 pause, or resume print job. User name: %s. Printer name: %s.",
2038 uidtoname(server_info->utok.uid),
2039 PRINTERNAME(snum) );
2046 * get the spooled filename of the print job
2047 * if this works, then the file has not been spooled
2048 * to the underlying print system. Just delete the
2049 * spool file & return.
2052 if ( (fname = print_job_fname( sharename, jobid )) != NULL )
2054 /* remove the spool file */
2055 DEBUG(10,("print_job_delete: Removing spool file [%s]\n", fname ));
2056 if ( unlink( fname ) == -1 ) {
2057 *errcode = map_werror_from_unix(errno);
2062 if (!print_job_delete1(snum, jobid)) {
2063 *errcode = WERR_ACCESS_DENIED;
2067 /* force update the database and say the delete failed if the
2070 print_queue_update(snum, True);
2072 pjob = print_job_find(sharename, jobid);
2073 if ( pjob && (pjob->status != LPQ_DELETING) )
2074 *errcode = WERR_ACCESS_DENIED;
2076 return (pjob == NULL );
2079 /****************************************************************************
2081 ****************************************************************************/
2083 bool print_job_pause(struct auth_serversupplied_info *server_info, int snum,
2084 uint32 jobid, WERROR *errcode)
2086 const char* sharename = lp_const_servicename(snum);
2087 struct printjob *pjob;
2089 struct printif *current_printif = get_printer_fns( snum );
2091 pjob = print_job_find(sharename, jobid);
2093 if (!pjob || !server_info) {
2094 DEBUG(10, ("print_job_pause: no pjob or user for jobid %u\n",
2095 (unsigned int)jobid ));
2099 if (!pjob->spooled || pjob->sysjob == -1) {
2100 DEBUG(10, ("print_job_pause: not spooled or bad sysjob = %d for jobid %u\n",
2101 (int)pjob->sysjob, (unsigned int)jobid ));
2105 if (!is_owner(server_info, lp_const_servicename(snum), jobid) &&
2106 !print_access_check(server_info, snum, JOB_ACCESS_ADMINISTER)) {
2107 DEBUG(3, ("pause denied by security descriptor\n"));
2109 /* BEGIN_ADMIN_LOG */
2110 sys_adminlog( LOG_ERR,
2111 "Permission denied-- user not allowed to delete, \
2112 pause, or resume print job. User name: %s. Printer name: %s.",
2113 uidtoname(server_info->utok.uid),
2114 PRINTERNAME(snum) );
2117 *errcode = WERR_ACCESS_DENIED;
2121 /* need to pause the spooled entry */
2122 ret = (*(current_printif->job_pause))(snum, pjob);
2125 *errcode = WERR_INVALID_PARAM;
2129 /* force update the database */
2130 print_cache_flush(lp_const_servicename(snum));
2132 /* Send a printer notify message */
2134 notify_job_status(sharename, jobid, JOB_STATUS_PAUSED);
2136 /* how do we tell if this succeeded? */
2141 /****************************************************************************
2143 ****************************************************************************/
2145 bool print_job_resume(struct auth_serversupplied_info *server_info, int snum,
2146 uint32 jobid, WERROR *errcode)
2148 const char *sharename = lp_const_servicename(snum);
2149 struct printjob *pjob;
2151 struct printif *current_printif = get_printer_fns( snum );
2153 pjob = print_job_find(sharename, jobid);
2155 if (!pjob || !server_info) {
2156 DEBUG(10, ("print_job_resume: no pjob or user for jobid %u\n",
2157 (unsigned int)jobid ));
2161 if (!pjob->spooled || pjob->sysjob == -1) {
2162 DEBUG(10, ("print_job_resume: not spooled or bad sysjob = %d for jobid %u\n",
2163 (int)pjob->sysjob, (unsigned int)jobid ));
2167 if (!is_owner(server_info, lp_const_servicename(snum), jobid) &&
2168 !print_access_check(server_info, snum, JOB_ACCESS_ADMINISTER)) {
2169 DEBUG(3, ("resume denied by security descriptor\n"));
2170 *errcode = WERR_ACCESS_DENIED;
2172 /* BEGIN_ADMIN_LOG */
2173 sys_adminlog( LOG_ERR,
2174 "Permission denied-- user not allowed to delete, \
2175 pause, or resume print job. User name: %s. Printer name: %s.",
2176 uidtoname(server_info->utok.uid),
2177 PRINTERNAME(snum) );
2182 ret = (*(current_printif->job_resume))(snum, pjob);
2185 *errcode = WERR_INVALID_PARAM;
2189 /* force update the database */
2190 print_cache_flush(lp_const_servicename(snum));
2192 /* Send a printer notify message */
2194 notify_job_status(sharename, jobid, JOB_STATUS_QUEUED);
2199 /****************************************************************************
2200 Write to a print file.
2201 ****************************************************************************/
2203 ssize_t print_job_write(int snum, uint32 jobid, const char *buf, SMB_OFF_T pos, size_t size)
2205 const char* sharename = lp_const_servicename(snum);
2206 ssize_t return_code;
2207 struct printjob *pjob;
2209 pjob = print_job_find(sharename, jobid);
2213 /* don't allow another process to get this info - it is meaningless */
2214 if (pjob->pid != sys_getpid())
2217 return_code = write_data_at_offset(pjob->fd, buf, size, pos);
2219 if (return_code>0) {
2221 pjob_store(sharename, jobid, pjob);
2226 /****************************************************************************
2227 Get the queue status - do not update if db is out of date.
2228 ****************************************************************************/
2230 static int get_queue_status(const char* sharename, print_status_struct *status)
2234 struct tdb_print_db *pdb = get_print_db_byname(sharename);
2238 ZERO_STRUCTP(status);
2245 fstr_sprintf(keystr, "STATUS/%s", sharename);
2246 data = tdb_fetch(pdb->tdb, string_tdb_data(keystr));
2248 if (data.dsize == sizeof(print_status_struct))
2249 /* this memcpy is ok since the status struct was
2250 not packed before storing it in the tdb */
2251 memcpy(status, data.dptr, sizeof(print_status_struct));
2252 SAFE_FREE(data.dptr);
2255 len = tdb_fetch_int32(pdb->tdb, "INFO/total_jobs");
2256 release_print_db(pdb);
2257 return (len == -1 ? 0 : len);
2260 /****************************************************************************
2261 Determine the number of jobs in a queue.
2262 ****************************************************************************/
2264 int print_queue_length(int snum, print_status_struct *pstatus)
2266 const char* sharename = lp_const_servicename( snum );
2267 print_status_struct status;
2270 ZERO_STRUCT( status );
2272 /* make sure the database is up to date */
2273 if (print_cache_expired(lp_const_servicename(snum), True))
2274 print_queue_update(snum, False);
2276 /* also fetch the queue status */
2277 memset(&status, 0, sizeof(status));
2278 len = get_queue_status(sharename, &status);
2286 /***************************************************************************
2287 Allocate a jobid. Hold the lock for as short a time as possible.
2288 ***************************************************************************/
2290 static bool allocate_print_jobid(struct tdb_print_db *pdb, int snum, const char *sharename, uint32 *pjobid)
2295 *pjobid = (uint32)-1;
2297 for (i = 0; i < 3; i++) {
2298 /* Lock the database - only wait 20 seconds. */
2299 if (tdb_lock_bystring_with_timeout(pdb->tdb, "INFO/nextjob", 20) == -1) {
2300 DEBUG(0,("allocate_print_jobid: failed to lock printing database %s\n", sharename));
2304 if (!tdb_fetch_uint32(pdb->tdb, "INFO/nextjob", &jobid)) {
2305 if (tdb_error(pdb->tdb) != TDB_ERR_NOEXIST) {
2306 DEBUG(0, ("allocate_print_jobid: failed to fetch INFO/nextjob for print queue %s\n",
2308 tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
2311 DEBUG(10,("allocate_print_jobid: no existing jobid in %s\n", sharename));
2315 DEBUG(10,("allocate_print_jobid: read jobid %u from %s\n", jobid, sharename));
2317 jobid = NEXT_JOBID(jobid);
2319 if (tdb_store_int32(pdb->tdb, "INFO/nextjob", jobid)==-1) {
2320 DEBUG(3, ("allocate_print_jobid: failed to store INFO/nextjob.\n"));
2321 tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
2325 /* We've finished with the INFO/nextjob lock. */
2326 tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
2328 if (!print_job_exists(sharename, jobid)) {
2331 DEBUG(10,("allocate_print_jobid: found jobid %u in %s\n", jobid, sharename));
2335 DEBUG(0, ("allocate_print_jobid: failed to allocate a print job for queue %s\n",
2337 /* Probably full... */
2342 /* Store a dummy placeholder. */
2348 if (tdb_store(pdb->tdb, print_key(jobid, &tmp), dum,
2349 TDB_INSERT) == -1) {
2350 DEBUG(3, ("allocate_print_jobid: jobid (%d) failed to store placeholder.\n",
2360 /***************************************************************************
2361 Append a jobid to the 'jobs changed' list.
2362 ***************************************************************************/
2364 static bool add_to_jobs_changed(struct tdb_print_db *pdb, uint32 jobid)
2369 SIVAL(&store_jobid, 0, jobid);
2370 data.dptr = (uint8 *)&store_jobid;
2373 DEBUG(10,("add_to_jobs_changed: Added jobid %u\n", (unsigned int)jobid ));
2375 return (tdb_append(pdb->tdb, string_tdb_data("INFO/jobs_changed"),
2379 /***************************************************************************
2380 Start spooling a job - return the jobid.
2381 ***************************************************************************/
2383 uint32 print_job_start(struct auth_serversupplied_info *server_info, int snum,
2384 const char *jobname, NT_DEVICEMODE *nt_devmode )
2388 struct printjob pjob;
2389 const char *sharename = lp_const_servicename(snum);
2390 struct tdb_print_db *pdb = get_print_db_byname(sharename);
2398 if (!print_access_check(server_info, snum, PRINTER_ACCESS_USE)) {
2399 DEBUG(3, ("print_job_start: job start denied by security descriptor\n"));
2400 release_print_db(pdb);
2404 if (!print_time_access_check(lp_servicename(snum))) {
2405 DEBUG(3, ("print_job_start: job start denied by time check\n"));
2406 release_print_db(pdb);
2410 path = lp_pathname(snum);
2412 /* see if we have sufficient disk space */
2413 if (lp_minprintspace(snum)) {
2414 uint64_t dspace, dsize;
2415 if (sys_fsusage(path, &dspace, &dsize) == 0 &&
2416 dspace < 2*(uint64_t)lp_minprintspace(snum)) {
2417 DEBUG(3, ("print_job_start: disk space check failed.\n"));
2418 release_print_db(pdb);
2424 /* for autoloaded printers, check that the printcap entry still exists */
2425 if (lp_autoloaded(snum) && !pcap_printername_ok(lp_const_servicename(snum))) {
2426 DEBUG(3, ("print_job_start: printer name %s check failed.\n", lp_const_servicename(snum) ));
2427 release_print_db(pdb);
2432 /* Insure the maximum queue size is not violated */
2433 if ((njobs = print_queue_length(snum,NULL)) > lp_maxprintjobs(snum)) {
2434 DEBUG(3, ("print_job_start: Queue %s number of jobs (%d) larger than max printjobs per queue (%d).\n",
2435 sharename, njobs, lp_maxprintjobs(snum) ));
2436 release_print_db(pdb);
2441 DEBUG(10,("print_job_start: Queue %s number of jobs (%d), max printjobs = %d\n",
2442 sharename, njobs, lp_maxprintjobs(snum) ));
2444 if (!allocate_print_jobid(pdb, snum, sharename, &jobid))
2447 /* create the database entry */
2451 pjob.pid = sys_getpid();
2454 pjob.starttime = time(NULL);
2455 pjob.status = LPQ_SPOOLING;
2457 pjob.spooled = False;
2459 pjob.nt_devmode = nt_devmode;
2461 fstrcpy(pjob.jobname, jobname);
2463 fstrcpy(pjob.user, lp_printjob_username(snum));
2464 standard_sub_advanced(sharename, server_info->sanitized_username,
2465 path, server_info->utok.gid,
2466 server_info->sanitized_username,
2467 pdb_get_domain(server_info->sam_account),
2468 pjob.user, sizeof(pjob.user)-1);
2469 /* ensure NULL termination */
2470 pjob.user[sizeof(pjob.user)-1] = '\0';
2472 fstrcpy(pjob.queuename, lp_const_servicename(snum));
2474 /* we have a job entry - now create the spool file */
2475 slprintf(pjob.filename, sizeof(pjob.filename)-1, "%s/%s%.8u.XXXXXX",
2476 path, PRINT_SPOOL_PREFIX, (unsigned int)jobid);
2477 pjob.fd = mkstemp(pjob.filename);
2479 if (pjob.fd == -1) {
2480 if (errno == EACCES) {
2481 /* Common setup error, force a report. */
2482 DEBUG(0, ("print_job_start: insufficient permissions \
2483 to open spool file %s.\n", pjob.filename));
2485 /* Normal case, report at level 3 and above. */
2486 DEBUG(3, ("print_job_start: can't open spool file %s,\n", pjob.filename));
2487 DEBUGADD(3, ("errno = %d (%s).\n", errno, strerror(errno)));
2492 pjob_store(sharename, jobid, &pjob);
2494 /* Update the 'jobs changed' entry used by print_queue_status. */
2495 add_to_jobs_changed(pdb, jobid);
2497 /* Ensure we keep a rough count of the number of total jobs... */
2498 tdb_change_int32_atomic(pdb->tdb, "INFO/total_jobs", &njobs, 1);
2500 release_print_db(pdb);
2506 pjob_delete(sharename, jobid);
2508 release_print_db(pdb);
2510 DEBUG(3, ("print_job_start: returning fail. Error = %s\n", strerror(errno) ));
2514 /****************************************************************************
2515 Update the number of pages spooled to jobid
2516 ****************************************************************************/
2518 void print_job_endpage(int snum, uint32 jobid)
2520 const char* sharename = lp_const_servicename(snum);
2521 struct printjob *pjob;
2523 pjob = print_job_find(sharename, jobid);
2526 /* don't allow another process to get this info - it is meaningless */
2527 if (pjob->pid != sys_getpid())
2531 pjob_store(sharename, jobid, pjob);
2534 /****************************************************************************
2535 Print a file - called on closing the file. This spools the job.
2536 If normal close is false then we're tearing down the jobs - treat as an
2538 ****************************************************************************/
2540 bool print_job_end(int snum, uint32 jobid, enum file_close_type close_type)
2542 const char* sharename = lp_const_servicename(snum);
2543 struct printjob *pjob;
2545 SMB_STRUCT_STAT sbuf;
2546 struct printif *current_printif = get_printer_fns( snum );
2548 pjob = print_job_find(sharename, jobid);
2553 if (pjob->spooled || pjob->pid != sys_getpid())
2556 if ((close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) &&
2557 (sys_fstat(pjob->fd, &sbuf, false) == 0)) {
2558 pjob->size = sbuf.st_ex_size;
2564 * Not a normal close or we couldn't stat the job file,
2565 * so something has gone wrong. Cleanup.
2569 DEBUG(3,("print_job_end: failed to stat file for jobid %d\n", jobid ));
2573 /* Technically, this is not quite right. If the printer has a separator
2574 * page turned on, the NT spooler prints the separator page even if the
2575 * print job is 0 bytes. 010215 JRR */
2576 if (pjob->size == 0 || pjob->status == LPQ_DELETING) {
2577 /* don't bother spooling empty files or something being deleted. */
2578 DEBUG(5,("print_job_end: canceling spool of %s (%s)\n",
2579 pjob->filename, pjob->size ? "deleted" : "zero length" ));
2580 unlink(pjob->filename);
2581 pjob_delete(sharename, jobid);
2585 ret = (*(current_printif->job_submit))(snum, pjob);
2590 /* The print job has been successfully handed over to the back-end */
2592 pjob->spooled = True;
2593 pjob->status = LPQ_QUEUED;
2594 pjob_store(sharename, jobid, pjob);
2596 /* make sure the database is up to date */
2597 if (print_cache_expired(lp_const_servicename(snum), True))
2598 print_queue_update(snum, False);
2604 /* The print job was not successfully started. Cleanup */
2605 /* Still need to add proper error return propagation! 010122:JRR */
2606 unlink(pjob->filename);
2607 pjob_delete(sharename, jobid);
2611 /****************************************************************************
2612 Get a snapshot of jobs in the system without traversing.
2613 ****************************************************************************/
2615 static bool get_stored_queue_info(struct tdb_print_db *pdb, int snum, int *pcount, print_queue_struct **ppqueue)
2617 TDB_DATA data, cgdata;
2618 print_queue_struct *queue = NULL;
2620 uint32 extra_count = 0;
2621 int total_count = 0;
2624 int max_reported_jobs = lp_max_reported_jobs(snum);
2626 const char* sharename = lp_servicename(snum);
2628 /* make sure the database is up to date */
2629 if (print_cache_expired(lp_const_servicename(snum), True))
2630 print_queue_update(snum, False);
2636 ZERO_STRUCT(cgdata);
2638 /* Get the stored queue data. */
2639 data = tdb_fetch(pdb->tdb, string_tdb_data("INFO/linear_queue_array"));
2641 if (data.dptr && data.dsize >= sizeof(qcount))
2642 len += tdb_unpack(data.dptr + len, data.dsize - len, "d", &qcount);
2644 /* Get the changed jobs list. */
2645 cgdata = tdb_fetch(pdb->tdb, string_tdb_data("INFO/jobs_changed"));
2646 if (cgdata.dptr != NULL && (cgdata.dsize % 4 == 0))
2647 extra_count = cgdata.dsize/4;
2649 DEBUG(5,("get_stored_queue_info: qcount = %u, extra_count = %u\n", (unsigned int)qcount, (unsigned int)extra_count));
2651 /* Allocate the queue size. */
2652 if (qcount == 0 && extra_count == 0)
2655 if ((queue = SMB_MALLOC_ARRAY(print_queue_struct, qcount + extra_count)) == NULL)
2658 /* Retrieve the linearised queue data. */
2660 for( i = 0; i < qcount; i++) {
2661 uint32 qjob, qsize, qpage_count, qstatus, qpriority, qtime;
2662 len += tdb_unpack(data.dptr + len, data.dsize - len, "ddddddff",
2671 queue[i].job = qjob;
2672 queue[i].size = qsize;
2673 queue[i].page_count = qpage_count;
2674 queue[i].status = qstatus;
2675 queue[i].priority = qpriority;
2676 queue[i].time = qtime;
2679 total_count = qcount;
2681 /* Add in the changed jobids. */
2682 for( i = 0; i < extra_count; i++) {
2684 struct printjob *pjob;
2686 jobid = IVAL(cgdata.dptr, i*4);
2687 DEBUG(5,("get_stored_queue_info: changed job = %u\n", (unsigned int)jobid));
2688 pjob = print_job_find(lp_const_servicename(snum), jobid);
2690 DEBUG(5,("get_stored_queue_info: failed to find changed job = %u\n", (unsigned int)jobid));
2691 remove_from_jobs_changed(sharename, jobid);
2695 queue[total_count].job = jobid;
2696 queue[total_count].size = pjob->size;
2697 queue[total_count].page_count = pjob->page_count;
2698 queue[total_count].status = pjob->status;
2699 queue[total_count].priority = 1;
2700 queue[total_count].time = pjob->starttime;
2701 fstrcpy(queue[total_count].fs_user, pjob->user);
2702 fstrcpy(queue[total_count].fs_file, pjob->jobname);
2706 /* Sort the queue by submission time otherwise they are displayed
2709 TYPESAFE_QSORT(queue, total_count, printjob_comp);
2711 DEBUG(5,("get_stored_queue_info: total_count = %u\n", (unsigned int)total_count));
2713 if (max_reported_jobs && total_count > max_reported_jobs)
2714 total_count = max_reported_jobs;
2717 *pcount = total_count;
2723 SAFE_FREE(data.dptr);
2724 SAFE_FREE(cgdata.dptr);
2728 /****************************************************************************
2729 Get a printer queue listing.
2730 set queue = NULL and status = NULL if you just want to update the cache
2731 ****************************************************************************/
2733 int print_queue_status(int snum,
2734 print_queue_struct **ppqueue,
2735 print_status_struct *status)
2739 const char *sharename;
2740 struct tdb_print_db *pdb;
2743 /* make sure the database is up to date */
2745 if (print_cache_expired(lp_const_servicename(snum), True))
2746 print_queue_update(snum, False);
2748 /* return if we are done */
2749 if ( !ppqueue || !status )
2753 sharename = lp_const_servicename(snum);
2754 pdb = get_print_db_byname(sharename);
2760 * Fetch the queue status. We must do this first, as there may
2761 * be no jobs in the queue.
2764 ZERO_STRUCTP(status);
2765 slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", sharename);
2766 key = string_tdb_data(keystr);
2768 data = tdb_fetch(pdb->tdb, key);
2770 if (data.dsize == sizeof(*status)) {
2771 /* this memcpy is ok since the status struct was
2772 not packed before storing it in the tdb */
2773 memcpy(status, data.dptr, sizeof(*status));
2775 SAFE_FREE(data.dptr);
2779 * Now, fetch the print queue information. We first count the number
2780 * of entries, and then only retrieve the queue if necessary.
2783 if (!get_stored_queue_info(pdb, snum, &count, ppqueue)) {
2784 release_print_db(pdb);
2788 release_print_db(pdb);
2792 /****************************************************************************
2794 ****************************************************************************/
2796 WERROR print_queue_pause(struct auth_serversupplied_info *server_info, int snum)
2799 struct printif *current_printif = get_printer_fns( snum );
2801 if (!print_access_check(server_info, snum,
2802 PRINTER_ACCESS_ADMINISTER)) {
2803 return WERR_ACCESS_DENIED;
2809 ret = (*(current_printif->queue_pause))(snum);
2814 return WERR_INVALID_PARAM;
2817 /* force update the database */
2818 print_cache_flush(lp_const_servicename(snum));
2820 /* Send a printer notify message */
2822 notify_printer_status(snum, PRINTER_STATUS_PAUSED);
2827 /****************************************************************************
2829 ****************************************************************************/
2831 WERROR print_queue_resume(struct auth_serversupplied_info *server_info, int snum)
2834 struct printif *current_printif = get_printer_fns( snum );
2836 if (!print_access_check(server_info, snum,
2837 PRINTER_ACCESS_ADMINISTER)) {
2838 return WERR_ACCESS_DENIED;
2843 ret = (*(current_printif->queue_resume))(snum);
2848 return WERR_INVALID_PARAM;
2851 /* make sure the database is up to date */
2852 if (print_cache_expired(lp_const_servicename(snum), True))
2853 print_queue_update(snum, True);
2855 /* Send a printer notify message */
2857 notify_printer_status(snum, PRINTER_STATUS_OK);
2862 /****************************************************************************
2863 Purge a queue - implemented by deleting all jobs that we can delete.
2864 ****************************************************************************/
2866 WERROR print_queue_purge(struct auth_serversupplied_info *server_info, int snum)
2868 print_queue_struct *queue;
2869 print_status_struct status;
2873 /* Force and update so the count is accurate (i.e. not a cached count) */
2874 print_queue_update(snum, True);
2876 can_job_admin = print_access_check(server_info, snum,
2877 JOB_ACCESS_ADMINISTER);
2878 njobs = print_queue_status(snum, &queue, &status);
2880 if ( can_job_admin )
2883 for (i=0;i<njobs;i++) {
2884 bool owner = is_owner(server_info, lp_const_servicename(snum),
2887 if (owner || can_job_admin) {
2888 print_job_delete1(snum, queue[i].job);
2892 if ( can_job_admin )
2895 /* update the cache */
2896 print_queue_update( snum, True );