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 SIG_ATOMIC_T got_sig_term;
26 extern SIG_ATOMIC_T reload_after_sighup;
27 extern struct current_user current_user;
28 extern userdom_struct current_user_info;
30 /* Current printer interface */
31 static BOOL remove_from_jobs_changed(const char* sharename, uint32 jobid);
34 the printing backend revolves around a tdb database that stores the
35 SMB view of the print queue
37 The key for this database is a jobid - a internally generated number that
38 uniquely identifies a print job
40 reading the print queue involves two steps:
41 - possibly running lpq and updating the internal database from that
42 - reading entries from the database
44 jobids are assigned when a job starts spooling.
47 static TDB_CONTEXT *rap_tdb;
48 static uint16 next_rap_jobid;
49 struct rap_jobid_key {
54 /***************************************************************************
55 Nightmare. LANMAN jobid's are 16 bit numbers..... We must map them to 32
56 bit RPC jobids.... JRA.
57 ***************************************************************************/
59 uint16 pjobid_to_rap(const char* sharename, uint32 jobid)
63 struct rap_jobid_key jinfo;
66 DEBUG(10,("pjobid_to_rap: called.\n"));
69 /* Create the in-memory tdb. */
70 rap_tdb = tdb_open_log(NULL, 0, TDB_INTERNAL, (O_RDWR|O_CREAT), 0644);
76 fstrcpy( jinfo.sharename, sharename );
78 key.dptr = (uint8 *)&jinfo;
79 key.dsize = sizeof(jinfo);
81 data = tdb_fetch(rap_tdb, key);
82 if (data.dptr && data.dsize == sizeof(uint16)) {
83 rap_jobid = SVAL(data.dptr, 0);
85 DEBUG(10,("pjobid_to_rap: jobid %u maps to RAP jobid %u\n",
86 (unsigned int)jobid, (unsigned int)rap_jobid));
90 /* Not found - create and store mapping. */
91 rap_jobid = ++next_rap_jobid;
93 rap_jobid = ++next_rap_jobid;
94 SSVAL(buf,0,rap_jobid);
96 data.dsize = sizeof(rap_jobid);
97 tdb_store(rap_tdb, key, data, TDB_REPLACE);
98 tdb_store(rap_tdb, data, key, TDB_REPLACE);
100 DEBUG(10,("pjobid_to_rap: created jobid %u maps to RAP jobid %u\n",
101 (unsigned int)jobid, (unsigned int)rap_jobid));
105 BOOL rap_to_pjobid(uint16 rap_jobid, fstring sharename, uint32 *pjobid)
110 DEBUG(10,("rap_to_pjobid called.\n"));
115 SSVAL(buf,0,rap_jobid);
117 key.dsize = sizeof(rap_jobid);
118 data = tdb_fetch(rap_tdb, key);
119 if ( data.dptr && data.dsize == sizeof(struct rap_jobid_key) )
121 struct rap_jobid_key *jinfo = (struct rap_jobid_key*)data.dptr;
122 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 pstring printing_path;
184 int services = lp_numservices();
187 unlink(lock_path("printing.tdb"));
188 pstrcpy(printing_path,lock_path("printing"));
189 mkdir(printing_path,0755);
191 /* handle a Samba upgrade */
193 for (snum = 0; snum < services; snum++) {
194 struct tdb_print_db *pdb;
195 if (!lp_print_ok(snum))
198 pdb = get_print_db_byname(lp_const_servicename(snum));
201 if (tdb_lock_bystring(pdb->tdb, sversion) == -1) {
202 DEBUG(0,("print_backend_init: Failed to open printer %s database\n", lp_const_servicename(snum) ));
203 release_print_db(pdb);
206 if (tdb_fetch_int32(pdb->tdb, sversion) != PRINT_DATABASE_VERSION) {
207 tdb_traverse(pdb->tdb, tdb_traverse_delete_fn, NULL);
208 tdb_store_int32(pdb->tdb, sversion, PRINT_DATABASE_VERSION);
210 tdb_unlock_bystring(pdb->tdb, sversion);
211 release_print_db(pdb);
214 close_all_print_db(); /* Don't leave any open. */
216 /* do NT print initialization... */
217 return nt_printing_init(msg_ctx);
220 /****************************************************************************
221 Shut down printing backend. Called once at shutdown to close the tdb.
222 ****************************************************************************/
224 void printing_end(void)
226 close_all_print_db(); /* Don't leave any open. */
229 /****************************************************************************
230 Retrieve the set of printing functions for a given service. This allows
231 us to set the printer function table based on the value of the 'printing'
234 Use the generic interface as the default and only use cups interface only
235 when asked for (and only when supported)
236 ****************************************************************************/
238 static struct printif *get_printer_fns_from_type( enum printing_types type )
240 struct printif *printer_fns = &generic_printif;
243 if ( type == PRINT_CUPS ) {
244 printer_fns = &cups_printif;
246 #endif /* HAVE_CUPS */
249 if ( type == PRINT_IPRINT ) {
250 printer_fns = &iprint_printif;
252 #endif /* HAVE_IPRINT */
254 printer_fns->type = type;
259 static struct printif *get_printer_fns( int snum )
261 return get_printer_fns_from_type( (enum printing_types)lp_printing(snum) );
265 /****************************************************************************
266 Useful function to generate a tdb key.
267 ****************************************************************************/
269 static TDB_DATA print_key(uint32 jobid)
275 ret.dptr = (uint8 *)&j;
276 ret.dsize = sizeof(j);
280 /***********************************************************************
281 unpack a pjob from a tdb buffer
282 ***********************************************************************/
284 int unpack_pjob( uint8 *buf, int buflen, struct printjob *pjob )
288 uint32 pjpid, pjsysjob, pjfd, pjstarttime, pjstatus;
289 uint32 pjsize, pjpage_count, pjspooled, pjsmbjob;
294 len += tdb_unpack(buf+len, buflen-len, "dddddddddffff",
312 if ( (used = unpack_devicemode(&pjob->nt_devmode, buf+len, buflen-len)) == -1 )
318 pjob->sysjob = pjsysjob;
320 pjob->starttime = pjstarttime;
321 pjob->status = pjstatus;
323 pjob->page_count = pjpage_count;
324 pjob->spooled = pjspooled;
325 pjob->smbjob = pjsmbjob;
331 /****************************************************************************
332 Useful function to find a print job in the database.
333 ****************************************************************************/
335 static struct printjob *print_job_find(const char *sharename, uint32 jobid)
337 static struct printjob pjob;
339 struct tdb_print_db *pdb = get_print_db_byname(sharename);
341 DEBUG(10,("print_job_find: looking up job %u for share %s\n",
342 (unsigned int)jobid, sharename ));
348 ret = tdb_fetch(pdb->tdb, print_key(jobid));
349 release_print_db(pdb);
352 DEBUG(10,("print_job_find: failed to find jobid %u.\n", (unsigned int)jobid ));
356 if ( pjob.nt_devmode ) {
357 free_nt_devicemode( &pjob.nt_devmode );
362 if ( unpack_pjob( ret.dptr, ret.dsize, &pjob ) == -1 ) {
363 DEBUG(10,("print_job_find: failed to unpack jobid %u.\n", (unsigned int)jobid ));
370 DEBUG(10,("print_job_find: returning system job %d for jobid %u.\n",
371 (int)pjob.sysjob, (unsigned int)jobid ));
376 /* Convert a unix jobid to a smb jobid */
378 static uint32 sysjob_to_jobid_value;
380 static int unixjob_traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA key,
381 TDB_DATA data, void *state)
383 struct printjob *pjob;
384 int *sysjob = (int *)state;
386 if (!data.dptr || data.dsize == 0)
389 pjob = (struct printjob *)data.dptr;
390 if (key.dsize != sizeof(uint32))
393 if (*sysjob == pjob->sysjob) {
394 uint32 jobid = IVAL(key.dptr,0);
396 sysjob_to_jobid_value = jobid;
403 /****************************************************************************
404 This is a *horribly expensive call as we have to iterate through all the
405 current printer tdb's. Don't do this often ! JRA.
406 ****************************************************************************/
408 uint32 sysjob_to_jobid(int unix_jobid)
410 int services = lp_numservices();
413 sysjob_to_jobid_value = (uint32)-1;
415 for (snum = 0; snum < services; snum++) {
416 struct tdb_print_db *pdb;
417 if (!lp_print_ok(snum))
419 pdb = get_print_db_byname(lp_const_servicename(snum));
423 tdb_traverse(pdb->tdb, unixjob_traverse_fn, &unix_jobid);
424 release_print_db(pdb);
425 if (sysjob_to_jobid_value != (uint32)-1)
426 return sysjob_to_jobid_value;
431 /****************************************************************************
432 Send notifications based on what has changed after a pjob_store.
433 ****************************************************************************/
437 uint32 spoolss_status;
438 } lpq_to_spoolss_status_map[] = {
439 { LPQ_QUEUED, JOB_STATUS_QUEUED },
440 { LPQ_PAUSED, JOB_STATUS_PAUSED },
441 { LPQ_SPOOLING, JOB_STATUS_SPOOLING },
442 { LPQ_PRINTING, JOB_STATUS_PRINTING },
443 { LPQ_DELETING, JOB_STATUS_DELETING },
444 { LPQ_OFFLINE, JOB_STATUS_OFFLINE },
445 { LPQ_PAPEROUT, JOB_STATUS_PAPEROUT },
446 { LPQ_PRINTED, JOB_STATUS_PRINTED },
447 { LPQ_DELETED, JOB_STATUS_DELETED },
448 { LPQ_BLOCKED, JOB_STATUS_BLOCKED },
449 { LPQ_USER_INTERVENTION, JOB_STATUS_USER_INTERVENTION },
453 /* Convert a lpq status value stored in printing.tdb into the
454 appropriate win32 API constant. */
456 static uint32 map_to_spoolss_status(uint32 lpq_status)
460 while (lpq_to_spoolss_status_map[i].lpq_status != -1) {
461 if (lpq_to_spoolss_status_map[i].lpq_status == lpq_status)
462 return lpq_to_spoolss_status_map[i].spoolss_status;
469 static void pjob_store_notify(const char* sharename, uint32 jobid, struct printjob *old_data,
470 struct printjob *new_data)
472 BOOL new_job = False;
477 /* Job attributes that can't be changed. We only send
478 notification for these on a new job. */
480 /* ACHTUNG! Due to a bug in Samba's spoolss parsing of the
481 NOTIFY_INFO_DATA buffer, we *have* to send the job submission
482 time first or else we'll end up with potential alignment
483 errors. I don't think the systemtime should be spooled as
484 a string, but this gets us around that error.
485 --jerry (i'll feel dirty for this) */
488 notify_job_submitted(sharename, jobid, new_data->starttime);
489 notify_job_username(sharename, jobid, new_data->user);
492 if (new_job || !strequal(old_data->jobname, new_data->jobname))
493 notify_job_name(sharename, jobid, new_data->jobname);
495 /* Job attributes of a new job or attributes that can be
498 if (new_job || !strequal(old_data->jobname, new_data->jobname))
499 notify_job_name(sharename, jobid, new_data->jobname);
501 if (new_job || old_data->status != new_data->status)
502 notify_job_status(sharename, jobid, map_to_spoolss_status(new_data->status));
504 if (new_job || old_data->size != new_data->size)
505 notify_job_total_bytes(sharename, jobid, new_data->size);
507 if (new_job || old_data->page_count != new_data->page_count)
508 notify_job_total_pages(sharename, jobid, new_data->page_count);
511 /****************************************************************************
512 Store a job structure back to the database.
513 ****************************************************************************/
515 static BOOL pjob_store(const char* sharename, uint32 jobid, struct printjob *pjob)
517 TDB_DATA old_data, new_data;
519 struct tdb_print_db *pdb = get_print_db_byname(sharename);
521 int len, newlen, buflen;
529 old_data = tdb_fetch(pdb->tdb, print_key(jobid));
531 /* Doh! Now we have to pack/unpack data since the NT_DEVICEMODE was added */
538 len += tdb_pack(buf+len, buflen-len, "dddddddddffff",
540 (uint32)pjob->sysjob,
542 (uint32)pjob->starttime,
543 (uint32)pjob->status,
545 (uint32)pjob->page_count,
546 (uint32)pjob->spooled,
547 (uint32)pjob->smbjob,
553 len += pack_devicemode(pjob->nt_devmode, buf+len, buflen-len);
556 buf = (uint8 *)SMB_REALLOC(buf, len);
558 DEBUG(0,("pjob_store: failed to enlarge buffer!\n"));
563 } while ( buflen != len );
569 new_data.dsize = len;
570 ret = (tdb_store(pdb->tdb, print_key(jobid), new_data, TDB_REPLACE) == 0);
572 release_print_db(pdb);
574 /* Send notify updates for what has changed */
577 struct printjob old_pjob;
579 if ( old_data.dsize )
581 if ( unpack_pjob( old_data.dptr, old_data.dsize, &old_pjob ) != -1 )
583 pjob_store_notify( sharename, jobid, &old_pjob , pjob );
584 free_nt_devicemode( &old_pjob.nt_devmode );
589 pjob_store_notify( sharename, jobid, NULL, pjob );
594 SAFE_FREE( old_data.dptr );
600 /****************************************************************************
601 Remove a job structure from the database.
602 ****************************************************************************/
604 void pjob_delete(const char* sharename, uint32 jobid)
606 struct printjob *pjob;
607 uint32 job_status = 0;
608 struct tdb_print_db *pdb;
610 pdb = get_print_db_byname( sharename );
615 pjob = print_job_find( sharename, jobid );
618 DEBUG(5, ("pjob_delete: we were asked to delete nonexistent job %u\n",
619 (unsigned int)jobid));
620 release_print_db(pdb);
624 /* We must cycle through JOB_STATUS_DELETING and
625 JOB_STATUS_DELETED for the port monitor to delete the job
628 job_status = JOB_STATUS_DELETING|JOB_STATUS_DELETED;
629 notify_job_status(sharename, jobid, job_status);
631 /* Remove from printing.tdb */
633 tdb_delete(pdb->tdb, print_key(jobid));
634 remove_from_jobs_changed(sharename, jobid);
635 release_print_db( pdb );
636 rap_jobid_delete(sharename, jobid);
639 /****************************************************************************
640 Parse a file name from the system spooler to generate a jobid.
641 ****************************************************************************/
643 static uint32 print_parse_jobid(char *fname)
647 if (strncmp(fname,PRINT_SPOOL_PREFIX,strlen(PRINT_SPOOL_PREFIX)) != 0)
649 fname += strlen(PRINT_SPOOL_PREFIX);
655 return (uint32)jobid;
658 /****************************************************************************
659 List a unix job in the print database.
660 ****************************************************************************/
662 static void print_unix_job(const char *sharename, print_queue_struct *q, uint32 jobid)
664 struct printjob pj, *old_pj;
666 if (jobid == (uint32)-1)
667 jobid = q->job + UNIX_JOB_START;
669 /* Preserve the timestamp on an existing unix print job */
671 old_pj = print_job_find(sharename, jobid);
678 pj.starttime = old_pj ? old_pj->starttime : q->time;
679 pj.status = q->status;
682 fstrcpy(pj.filename, old_pj ? old_pj->filename : "");
683 if (jobid < UNIX_JOB_START) {
685 fstrcpy(pj.jobname, old_pj ? old_pj->jobname : "Remote Downlevel Document");
688 fstrcpy(pj.jobname, old_pj ? old_pj->jobname : q->fs_file);
690 fstrcpy(pj.user, old_pj ? old_pj->user : q->fs_user);
691 fstrcpy(pj.queuename, old_pj ? old_pj->queuename : sharename );
693 pjob_store(sharename, jobid, &pj);
697 struct traverse_struct {
698 print_queue_struct *queue;
699 int qcount, snum, maxcount, total_jobs;
700 const char *sharename;
702 const char *lprm_command;
703 struct printif *print_if;
706 /****************************************************************************
707 Utility fn to delete any jobs that are no longer active.
708 ****************************************************************************/
710 static int traverse_fn_delete(TDB_CONTEXT *t, TDB_DATA key, TDB_DATA data, void *state)
712 struct traverse_struct *ts = (struct traverse_struct *)state;
713 struct printjob pjob;
717 if ( key.dsize != sizeof(jobid) )
720 jobid = IVAL(key.dptr, 0);
721 if ( unpack_pjob( data.dptr, data.dsize, &pjob ) == -1 )
723 free_nt_devicemode( &pjob.nt_devmode );
727 /* remove a unix job if it isn't in the system queue any more */
729 for (i=0;i<ts->qcount;i++) {
730 uint32 u_jobid = (ts->queue[i].job + UNIX_JOB_START);
731 if (jobid == u_jobid)
734 if (i == ts->qcount) {
735 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !smbjob\n",
736 (unsigned int)jobid ));
737 pjob_delete(ts->sharename, jobid);
741 /* need to continue the the bottom of the function to
742 save the correct attributes */
745 /* maybe it hasn't been spooled yet */
747 /* if a job is not spooled and the process doesn't
748 exist then kill it. This cleans up after smbd
750 if (!process_exists_by_pid(pjob.pid)) {
751 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !process_exists (%u)\n",
752 (unsigned int)jobid, (unsigned int)pjob.pid ));
753 pjob_delete(ts->sharename, jobid);
759 /* this check only makes sense for jobs submitted from Windows clients */
762 for (i=0;i<ts->qcount;i++) {
765 if ( pjob.status == LPQ_DELETED )
768 curr_jobid = print_parse_jobid(ts->queue[i].fs_file);
770 if (jobid == curr_jobid) {
772 /* try to clean up any jobs that need to be deleted */
774 if ( pjob.status == LPQ_DELETING ) {
777 result = (*(ts->print_if->job_delete))(
778 ts->sharename, ts->lprm_command, &pjob );
781 /* if we can't delete, then reset the job status */
782 pjob.status = LPQ_QUEUED;
783 pjob_store(ts->sharename, jobid, &pjob);
786 /* if we deleted the job, the remove the tdb record */
787 pjob_delete(ts->sharename, jobid);
788 pjob.status = LPQ_DELETED;
798 /* The job isn't in the system queue - we have to assume it has
799 completed, so delete the database entry. */
801 if (i == ts->qcount) {
803 /* A race can occur between the time a job is spooled and
804 when it appears in the lpq output. This happens when
805 the job is added to printing.tdb when another smbd
806 running print_queue_update() has completed a lpq and
807 is currently traversing the printing tdb and deleting jobs.
808 Don't delete the job if it was submitted after the lpq_time. */
810 if (pjob.starttime < ts->lpq_time) {
811 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to pjob.starttime (%u) < ts->lpq_time (%u)\n",
813 (unsigned int)pjob.starttime,
814 (unsigned int)ts->lpq_time ));
815 pjob_delete(ts->sharename, jobid);
821 /* Save the pjob attributes we will store.
822 FIXME!!! This is the only place where queue->job
823 represents the SMB jobid --jerry */
825 ts->queue[i].job = jobid;
826 ts->queue[i].size = pjob.size;
827 ts->queue[i].page_count = pjob.page_count;
828 ts->queue[i].status = pjob.status;
829 ts->queue[i].priority = 1;
830 ts->queue[i].time = pjob.starttime;
831 fstrcpy(ts->queue[i].fs_user, pjob.user);
832 fstrcpy(ts->queue[i].fs_file, pjob.jobname);
839 /****************************************************************************
840 Check if the print queue has been updated recently enough.
841 ****************************************************************************/
843 static void print_cache_flush(const char *sharename)
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);
869 key = string_tdb_data(keystr);
871 data = tdb_fetch(pdb->tdb, key);
872 release_print_db(pdb);
873 if (!data.dptr || data.dsize != sizeof(pid_t)) {
874 SAFE_FREE(data.dptr);
878 updating_pid = IVAL(data.dptr, 0);
879 SAFE_FREE(data.dptr);
881 if (process_exists_by_pid(updating_pid))
887 /****************************************************************************
888 Set the fact that we're doing the update, or have finished doing the update
890 ****************************************************************************/
892 static void set_updating_pid(const fstring sharename, BOOL updating)
897 pid_t updating_pid = sys_getpid();
900 struct tdb_print_db *pdb = get_print_db_byname(sharename);
905 slprintf(keystr, sizeof(keystr)-1, "UPDATING/%s", sharename);
906 key = string_tdb_data(keystr);
908 DEBUG(5, ("set_updating_pid: %s updating lpq cache for print share %s\n",
909 updating ? "" : "not ",
913 tdb_delete(pdb->tdb, key);
914 release_print_db(pdb);
918 SIVAL( buffer, 0, updating_pid);
920 data.dsize = 4; /* we always assume this is a 4 byte value */
922 tdb_store(pdb->tdb, key, data, TDB_REPLACE);
923 release_print_db(pdb);
926 /****************************************************************************
927 Sort print jobs by submittal time.
928 ****************************************************************************/
930 static int printjob_comp(print_queue_struct *j1, print_queue_struct *j2)
941 /* Sort on job start time */
943 if (j1->time == j2->time)
945 return (j1->time > j2->time) ? 1 : -1;
948 /****************************************************************************
949 Store the sorted queue representation for later portmon retrieval.
951 ****************************************************************************/
953 static void store_queue_struct(struct tdb_print_db *pdb, struct traverse_struct *pts)
956 int max_reported_jobs = lp_max_reported_jobs(pts->snum);
957 print_queue_struct *queue = pts->queue;
962 if (max_reported_jobs && (max_reported_jobs < pts->qcount))
963 pts->qcount = max_reported_jobs;
966 /* Work out the size. */
968 data.dsize += tdb_pack(NULL, 0, "d", qcount);
970 for (i = 0; i < pts->qcount; i++) {
971 if ( queue[i].status == LPQ_DELETED )
975 data.dsize += tdb_pack(NULL, 0, "ddddddff",
976 (uint32)queue[i].job,
977 (uint32)queue[i].size,
978 (uint32)queue[i].page_count,
979 (uint32)queue[i].status,
980 (uint32)queue[i].priority,
981 (uint32)queue[i].time,
986 if ((data.dptr = (uint8 *)SMB_MALLOC(data.dsize)) == NULL)
990 len += tdb_pack(data.dptr + len, data.dsize - len, "d", qcount);
991 for (i = 0; i < pts->qcount; i++) {
992 if ( queue[i].status == LPQ_DELETED )
995 len += tdb_pack(data.dptr + len, data.dsize - len, "ddddddff",
996 (uint32)queue[i].job,
997 (uint32)queue[i].size,
998 (uint32)queue[i].page_count,
999 (uint32)queue[i].status,
1000 (uint32)queue[i].priority,
1001 (uint32)queue[i].time,
1006 tdb_store(pdb->tdb, string_tdb_data("INFO/linear_queue_array"), data,
1008 SAFE_FREE(data.dptr);
1012 static TDB_DATA get_jobs_changed_data(struct tdb_print_db *pdb)
1018 data = tdb_fetch(pdb->tdb, string_tdb_data("INFO/jobs_changed"));
1019 if (data.dptr == NULL || data.dsize == 0 || (data.dsize % 4 != 0)) {
1020 SAFE_FREE(data.dptr);
1027 static void check_job_changed(const char *sharename, TDB_DATA data, uint32 jobid)
1030 unsigned int job_count = data.dsize / 4;
1032 for (i = 0; i < job_count; i++) {
1035 ch_jobid = IVAL(data.dptr, i*4);
1036 if (ch_jobid == jobid)
1037 remove_from_jobs_changed(sharename, jobid);
1041 /****************************************************************************
1042 Check if the print queue has been updated recently enough.
1043 ****************************************************************************/
1045 static BOOL print_cache_expired(const char *sharename, BOOL check_pending)
1048 time_t last_qscan_time, time_now = time(NULL);
1049 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1050 BOOL result = False;
1055 snprintf(key, sizeof(key), "CACHE/%s", sharename);
1056 last_qscan_time = (time_t)tdb_fetch_int32(pdb->tdb, key);
1059 * Invalidate the queue for 3 reasons.
1060 * (1). last queue scan time == -1.
1061 * (2). Current time - last queue scan time > allowed cache time.
1062 * (3). last queue scan time > current time + MAX_CACHE_VALID_TIME (1 hour by default).
1063 * This last test picks up machines for which the clock has been moved
1064 * forward, an lpq scan done and then the clock moved back. Otherwise
1065 * that last lpq scan would stay around for a loooong loooong time... :-). JRA.
1068 if (last_qscan_time == ((time_t)-1)
1069 || (time_now - last_qscan_time) >= lp_lpqcachetime()
1070 || last_qscan_time > (time_now + MAX_CACHE_VALID_TIME))
1073 time_t msg_pending_time;
1075 DEBUG(4, ("print_cache_expired: cache expired for queue %s "
1076 "(last_qscan_time = %d, time now = %d, qcachetime = %d)\n",
1077 sharename, (int)last_qscan_time, (int)time_now,
1078 (int)lp_lpqcachetime() ));
1080 /* check if another smbd has already sent a message to update the
1081 queue. Give the pending message one minute to clear and
1082 then send another message anyways. Make sure to check for
1083 clocks that have been run forward and then back again. */
1085 snprintf(key, sizeof(key), "MSG_PENDING/%s", sharename);
1088 && tdb_fetch_uint32( pdb->tdb, key, &u )
1089 && (msg_pending_time=u) > 0
1090 && msg_pending_time <= time_now
1091 && (time_now - msg_pending_time) < 60 )
1093 DEBUG(4,("print_cache_expired: message already pending for %s. Accepting cache\n",
1102 release_print_db(pdb);
1106 /****************************************************************************
1107 main work for updating the lpq cahe for a printer queue
1108 ****************************************************************************/
1110 static void print_queue_update_internal( const char *sharename,
1111 struct printif *current_printif,
1112 char *lpq_command, char *lprm_command )
1115 print_queue_struct *queue = NULL;
1116 print_status_struct status;
1117 print_status_struct old_status;
1118 struct printjob *pjob;
1119 struct traverse_struct tstruct;
1122 fstring keystr, cachestr;
1123 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1129 DEBUG(5,("print_queue_update_internal: printer = %s, type = %d, lpq command = [%s]\n",
1130 sharename, current_printif->type, lpq_command));
1133 * Update the cache time FIRST ! Stops others even
1134 * attempting to get the lock and doing this
1135 * if the lpq takes a long time.
1138 slprintf(cachestr, sizeof(cachestr)-1, "CACHE/%s", sharename);
1139 tdb_store_int32(pdb->tdb, cachestr, (int)time(NULL));
1141 /* get the current queue using the appropriate interface */
1142 ZERO_STRUCT(status);
1144 qcount = (*(current_printif->queue_get))(sharename,
1145 current_printif->type,
1146 lpq_command, &queue, &status);
1148 DEBUG(3, ("print_queue_update_internal: %d job%s in queue for %s\n",
1149 qcount, (qcount != 1) ? "s" : "", sharename));
1151 /* Sort the queue by submission time otherwise they are displayed
1154 qsort(queue, qcount, sizeof(print_queue_struct),
1155 QSORT_CAST(printjob_comp));
1158 any job in the internal database that is marked as spooled
1159 and doesn't exist in the system queue is considered finished
1160 and removed from the database
1162 any job in the system database but not in the internal database
1163 is added as a unix job
1165 fill in any system job numbers as we go
1168 jcdata = get_jobs_changed_data(pdb);
1170 for (i=0; i<qcount; i++) {
1171 uint32 jobid = print_parse_jobid(queue[i].fs_file);
1173 if (jobid == (uint32)-1) {
1174 /* assume its a unix print job */
1175 print_unix_job(sharename, &queue[i], jobid);
1179 /* we have an active SMB print job - update its status */
1180 pjob = print_job_find(sharename, jobid);
1182 /* err, somethings wrong. Probably smbd was restarted
1183 with jobs in the queue. All we can do is treat them
1184 like unix jobs. Pity. */
1185 print_unix_job(sharename, &queue[i], jobid);
1189 pjob->sysjob = queue[i].job;
1191 /* don't reset the status on jobs to be deleted */
1193 if ( pjob->status != LPQ_DELETING )
1194 pjob->status = queue[i].status;
1196 pjob_store(sharename, jobid, pjob);
1198 check_job_changed(sharename, jcdata, jobid);
1201 SAFE_FREE(jcdata.dptr);
1203 /* now delete any queued entries that don't appear in the
1205 tstruct.queue = queue;
1206 tstruct.qcount = qcount;
1208 tstruct.total_jobs = 0;
1209 tstruct.lpq_time = time(NULL);
1210 tstruct.sharename = sharename;
1211 tstruct.lprm_command = lprm_command;
1212 tstruct.print_if = current_printif;
1214 tdb_traverse(pdb->tdb, traverse_fn_delete, (void *)&tstruct);
1216 /* Store the linearised queue, max jobs only. */
1217 store_queue_struct(pdb, &tstruct);
1219 SAFE_FREE(tstruct.queue);
1221 DEBUG(10,("print_queue_update_internal: printer %s INFO/total_jobs = %d\n",
1222 sharename, tstruct.total_jobs ));
1224 tdb_store_int32(pdb->tdb, "INFO/total_jobs", tstruct.total_jobs);
1226 get_queue_status(sharename, &old_status);
1227 if (old_status.qcount != qcount)
1228 DEBUG(10,("print_queue_update_internal: queue status change %d jobs -> %d jobs for printer %s\n",
1229 old_status.qcount, qcount, sharename));
1231 /* store the new queue status structure */
1232 slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", sharename);
1233 key = string_tdb_data(keystr);
1235 status.qcount = qcount;
1236 data.dptr = (uint8 *)&status;
1237 data.dsize = sizeof(status);
1238 tdb_store(pdb->tdb, key, data, TDB_REPLACE);
1241 * Update the cache time again. We want to do this call
1242 * as little as possible...
1245 slprintf(keystr, sizeof(keystr)-1, "CACHE/%s", sharename);
1246 tdb_store_int32(pdb->tdb, keystr, (int32)time(NULL));
1248 /* clear the msg pending record for this queue */
1250 snprintf(keystr, sizeof(keystr), "MSG_PENDING/%s", sharename);
1252 if ( !tdb_store_uint32( pdb->tdb, keystr, 0 ) ) {
1253 /* log a message but continue on */
1255 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1259 release_print_db( pdb );
1264 /****************************************************************************
1265 Update the internal database from the system print queue for a queue.
1266 obtain a lock on the print queue before proceeding (needed when mutiple
1267 smbd processes maytry to update the lpq cache concurrently).
1268 ****************************************************************************/
1270 static void print_queue_update_with_lock( const char *sharename,
1271 struct printif *current_printif,
1272 char *lpq_command, char *lprm_command )
1275 struct tdb_print_db *pdb;
1277 DEBUG(5,("print_queue_update_with_lock: printer share = %s\n", sharename));
1278 pdb = get_print_db_byname(sharename);
1282 if ( !print_cache_expired(sharename, False) ) {
1283 DEBUG(5,("print_queue_update_with_lock: print cache for %s is still ok\n", sharename));
1284 release_print_db(pdb);
1289 * Check to see if someone else is doing this update.
1290 * This is essentially a mutex on the update.
1293 if (get_updating_pid(sharename) != -1) {
1294 release_print_db(pdb);
1298 /* Lock the queue for the database update */
1300 slprintf(keystr, sizeof(keystr) - 1, "LOCK/%s", sharename);
1301 /* Only wait 10 seconds for this. */
1302 if (tdb_lock_bystring_with_timeout(pdb->tdb, keystr, 10) == -1) {
1303 DEBUG(0,("print_queue_update_with_lock: Failed to lock printer %s database\n", sharename));
1304 release_print_db(pdb);
1309 * Ensure that no one else got in here.
1310 * If the updating pid is still -1 then we are
1314 if (get_updating_pid(sharename) != -1) {
1316 * Someone else is doing the update, exit.
1318 tdb_unlock_bystring(pdb->tdb, keystr);
1319 release_print_db(pdb);
1324 * We're going to do the update ourselves.
1327 /* Tell others we're doing the update. */
1328 set_updating_pid(sharename, True);
1331 * Allow others to enter and notice we're doing
1335 tdb_unlock_bystring(pdb->tdb, keystr);
1337 /* do the main work now */
1339 print_queue_update_internal( sharename, current_printif,
1340 lpq_command, lprm_command );
1342 /* Delete our pid from the db. */
1343 set_updating_pid(sharename, False);
1344 release_print_db(pdb);
1347 /****************************************************************************
1348 this is the receive function of the background lpq updater
1349 ****************************************************************************/
1350 static void print_queue_receive(struct messaging_context *msg,
1353 struct server_id server_id,
1357 pstring lpqcommand, lprmcommand;
1361 len = tdb_unpack( (uint8 *)data->data, data->length, "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",
1399 FLAG_MSG_GENERAL|FLAG_MSG_SMBD|FLAG_MSG_PRINT_GENERAL);
1401 if (!locking_init(0)) {
1405 messaging_register(smbd_messaging_context(), NULL,
1406 MSG_PRINTER_UPDATE, print_queue_receive);
1408 DEBUG(5,("start_background_queue: background LPQ thread waiting for messages\n"));
1412 /* check for some essential signals first */
1415 exit_server_cleanly(NULL);
1418 if (reload_after_sighup) {
1419 change_to_root_user();
1420 DEBUG(1,("Reloading services after SIGHUP\n"));
1421 reload_services(False);
1422 reload_after_sighup = 0;
1425 /* now check for messages */
1427 DEBUG(10,("start_background_queue: background LPQ thread got a message\n"));
1428 message_dispatch(smbd_messaging_context());
1430 /* process any pending print change notify messages */
1432 print_notify_send_messages(smbd_messaging_context(),
1438 /****************************************************************************
1439 update the internal database from the system print queue for a queue
1440 ****************************************************************************/
1442 static void print_queue_update(int snum, BOOL force)
1446 pstring lpqcommand, lprmcommand;
1447 uint8 *buffer = NULL;
1450 struct tdb_print_db *pdb;
1452 struct printif *current_printif;
1454 fstrcpy( sharename, lp_const_servicename(snum));
1456 /* don't strip out characters like '$' from the printername */
1458 pstrcpy( lpqcommand, lp_lpqcommand(snum));
1459 string_sub2( lpqcommand, "%p", PRINTERNAME(snum), sizeof(lpqcommand),
1460 False, False, False );
1461 standard_sub_advanced(lp_servicename(snum),
1462 current_user_info.unix_name, "",
1463 current_user.ut.gid,
1464 get_current_username(),
1465 current_user_info.domain,
1466 lpqcommand, sizeof(lpqcommand) );
1468 pstrcpy( lprmcommand, lp_lprmcommand(snum));
1469 string_sub2( lprmcommand, "%p", PRINTERNAME(snum), sizeof(lprmcommand),
1470 False, False, False );
1471 standard_sub_advanced(lp_servicename(snum),
1472 current_user_info.unix_name, "",
1473 current_user.ut.gid,
1474 get_current_username(),
1475 current_user_info.domain,
1476 lprmcommand, sizeof(lprmcommand) );
1479 * Make sure that the background queue process exists.
1480 * Otherwise just do the update ourselves
1483 if ( force || background_lpq_updater_pid == -1 ) {
1484 DEBUG(4,("print_queue_update: updating queue [%s] myself\n", sharename));
1485 current_printif = get_printer_fns( snum );
1486 print_queue_update_with_lock( sharename, current_printif, lpqcommand, lprmcommand );
1491 type = lp_printing(snum);
1493 /* get the length */
1495 len = tdb_pack( NULL, 0, "fdPP",
1501 buffer = SMB_XMALLOC_ARRAY( uint8, len );
1503 /* now pack the buffer */
1504 newlen = tdb_pack( buffer, len, "fdPP",
1510 SMB_ASSERT( newlen == len );
1512 DEBUG(10,("print_queue_update: Sending message -> printer = %s, "
1513 "type = %d, lpq command = [%s] lprm command = [%s]\n",
1514 sharename, type, lpqcommand, lprmcommand ));
1516 /* here we set a msg pending record for other smbd processes
1517 to throttle the number of duplicate print_queue_update msgs
1520 pdb = get_print_db_byname(sharename);
1526 snprintf(key, sizeof(key), "MSG_PENDING/%s", sharename);
1528 if ( !tdb_store_uint32( pdb->tdb, key, time(NULL) ) ) {
1529 /* log a message but continue on */
1531 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1535 release_print_db( pdb );
1537 /* finally send the message */
1539 messaging_send_buf(smbd_messaging_context(),
1540 pid_to_procid(background_lpq_updater_pid),
1541 MSG_PRINTER_UPDATE, (uint8 *)buffer, len);
1543 SAFE_FREE( buffer );
1548 /****************************************************************************
1549 Create/Update an entry in the print tdb that will allow us to send notify
1550 updates only to interested smbd's.
1551 ****************************************************************************/
1553 BOOL print_notify_register_pid(int snum)
1556 struct tdb_print_db *pdb = NULL;
1557 TDB_CONTEXT *tdb = NULL;
1558 const char *printername;
1559 uint32 mypid = (uint32)sys_getpid();
1563 /* if (snum == -1), then the change notify request was
1564 on a print server handle and we need to register on
1569 int num_services = lp_numservices();
1572 for ( idx=0; idx<num_services; idx++ ) {
1573 if (lp_snum_ok(idx) && lp_print_ok(idx) )
1574 print_notify_register_pid(idx);
1579 else /* register for a specific printer */
1581 printername = lp_const_servicename(snum);
1582 pdb = get_print_db_byname(printername);
1588 if (tdb_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) == -1) {
1589 DEBUG(0,("print_notify_register_pid: Failed to lock printer %s\n",
1592 release_print_db(pdb);
1596 data = get_printer_notify_pid_list( tdb, printername, True );
1598 /* Add ourselves and increase the refcount. */
1600 for (i = 0; i < data.dsize; i += 8) {
1601 if (IVAL(data.dptr,i) == mypid) {
1602 uint32 new_refcount = IVAL(data.dptr, i+4) + 1;
1603 SIVAL(data.dptr, i+4, new_refcount);
1608 if (i == data.dsize) {
1609 /* We weren't in the list. Realloc. */
1610 data.dptr = (uint8 *)SMB_REALLOC(data.dptr, data.dsize + 8);
1612 DEBUG(0,("print_notify_register_pid: Relloc fail for printer %s\n",
1617 SIVAL(data.dptr,data.dsize - 8,mypid);
1618 SIVAL(data.dptr,data.dsize - 4,1); /* Refcount. */
1621 /* Store back the record. */
1622 if (tdb_store_bystring(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) == -1) {
1623 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1624 list for printer %s\n", printername));
1632 tdb_unlock_bystring(tdb, NOTIFY_PID_LIST_KEY);
1634 release_print_db(pdb);
1635 SAFE_FREE(data.dptr);
1639 /****************************************************************************
1640 Update an entry in the print tdb that will allow us to send notify
1641 updates only to interested smbd's.
1642 ****************************************************************************/
1644 BOOL print_notify_deregister_pid(int snum)
1647 struct tdb_print_db *pdb = NULL;
1648 TDB_CONTEXT *tdb = NULL;
1649 const char *printername;
1650 uint32 mypid = (uint32)sys_getpid();
1654 /* if ( snum == -1 ), we are deregister a print server handle
1655 which means to deregister on all print queues */
1659 int num_services = lp_numservices();
1662 for ( idx=0; idx<num_services; idx++ ) {
1663 if ( lp_snum_ok(idx) && lp_print_ok(idx) )
1664 print_notify_deregister_pid(idx);
1669 else /* deregister a specific printer */
1671 printername = lp_const_servicename(snum);
1672 pdb = get_print_db_byname(printername);
1678 if (tdb_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) == -1) {
1679 DEBUG(0,("print_notify_register_pid: Failed to lock \
1680 printer %s database\n", printername));
1682 release_print_db(pdb);
1686 data = get_printer_notify_pid_list( tdb, printername, True );
1688 /* Reduce refcount. Remove ourselves if zero. */
1690 for (i = 0; i < data.dsize; ) {
1691 if (IVAL(data.dptr,i) == mypid) {
1692 uint32 refcount = IVAL(data.dptr, i+4);
1696 if (refcount == 0) {
1697 if (data.dsize - i > 8)
1698 memmove( &data.dptr[i], &data.dptr[i+8], data.dsize - i - 8);
1702 SIVAL(data.dptr, i+4, refcount);
1708 if (data.dsize == 0)
1709 SAFE_FREE(data.dptr);
1711 /* Store back the record. */
1712 if (tdb_store_bystring(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) == -1) {
1713 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1714 list for printer %s\n", printername));
1722 tdb_unlock_bystring(tdb, NOTIFY_PID_LIST_KEY);
1724 release_print_db(pdb);
1725 SAFE_FREE(data.dptr);
1729 /****************************************************************************
1730 Check if a jobid is valid. It is valid if it exists in the database.
1731 ****************************************************************************/
1733 BOOL print_job_exists(const char* sharename, uint32 jobid)
1735 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1740 ret = tdb_exists(pdb->tdb, print_key(jobid));
1741 release_print_db(pdb);
1745 /****************************************************************************
1746 Give the fd used for a jobid.
1747 ****************************************************************************/
1749 int print_job_fd(const char* sharename, uint32 jobid)
1751 struct printjob *pjob = print_job_find(sharename, jobid);
1754 /* don't allow another process to get this info - it is meaningless */
1755 if (pjob->pid != sys_getpid())
1760 /****************************************************************************
1761 Give the filename used for a jobid.
1762 Only valid for the process doing the spooling and when the job
1763 has not been spooled.
1764 ****************************************************************************/
1766 char *print_job_fname(const char* sharename, uint32 jobid)
1768 struct printjob *pjob = print_job_find(sharename, jobid);
1769 if (!pjob || pjob->spooled || pjob->pid != sys_getpid())
1771 return pjob->filename;
1775 /****************************************************************************
1776 Give the filename used for a jobid.
1777 Only valid for the process doing the spooling and when the job
1778 has not been spooled.
1779 ****************************************************************************/
1781 NT_DEVICEMODE *print_job_devmode(const char* sharename, uint32 jobid)
1783 struct printjob *pjob = print_job_find(sharename, jobid);
1788 return pjob->nt_devmode;
1791 /****************************************************************************
1792 Set the place in the queue for a job.
1793 ****************************************************************************/
1795 BOOL print_job_set_place(const char *sharename, uint32 jobid, int place)
1797 DEBUG(2,("print_job_set_place not implemented yet\n"));
1801 /****************************************************************************
1802 Set the name of a job. Only possible for owner.
1803 ****************************************************************************/
1805 BOOL print_job_set_name(const char *sharename, uint32 jobid, char *name)
1807 struct printjob *pjob;
1809 pjob = print_job_find(sharename, jobid);
1810 if (!pjob || pjob->pid != sys_getpid())
1813 fstrcpy(pjob->jobname, name);
1814 return pjob_store(sharename, jobid, pjob);
1817 /***************************************************************************
1818 Remove a jobid from the 'jobs changed' list.
1819 ***************************************************************************/
1821 static BOOL remove_from_jobs_changed(const char* sharename, uint32 jobid)
1823 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1825 size_t job_count, i;
1827 BOOL gotlock = False;
1835 key = string_tdb_data("INFO/jobs_changed");
1837 if (tdb_chainlock_with_timeout(pdb->tdb, key, 5) == -1)
1842 data = tdb_fetch(pdb->tdb, key);
1844 if (data.dptr == NULL || data.dsize == 0 || (data.dsize % 4 != 0))
1847 job_count = data.dsize / 4;
1848 for (i = 0; i < job_count; i++) {
1851 ch_jobid = IVAL(data.dptr, i*4);
1852 if (ch_jobid == jobid) {
1853 if (i < job_count -1 )
1854 memmove(data.dptr + (i*4), data.dptr + (i*4) + 4, (job_count - i - 1)*4 );
1856 if (tdb_store(pdb->tdb, key, data, TDB_REPLACE) == -1)
1866 tdb_chainunlock(pdb->tdb, key);
1867 SAFE_FREE(data.dptr);
1868 release_print_db(pdb);
1870 DEBUG(10,("remove_from_jobs_changed: removed jobid %u\n", (unsigned int)jobid ));
1872 DEBUG(10,("remove_from_jobs_changed: Failed to remove jobid %u\n", (unsigned int)jobid ));
1876 /****************************************************************************
1877 Delete a print job - don't update queue.
1878 ****************************************************************************/
1880 static BOOL print_job_delete1(int snum, uint32 jobid)
1882 const char* sharename = lp_const_servicename(snum);
1883 struct printjob *pjob = print_job_find(sharename, jobid);
1885 struct printif *current_printif = get_printer_fns( snum );
1891 * If already deleting just return.
1894 if (pjob->status == LPQ_DELETING)
1897 /* Hrm - we need to be able to cope with deleting a job before it
1898 has reached the spooler. Just mark it as LPQ_DELETING and
1899 let the print_queue_update() code rmeove the record */
1902 if (pjob->sysjob == -1) {
1903 DEBUG(5, ("attempt to delete job %u not seen by lpr\n", (unsigned int)jobid));
1906 /* Set the tdb entry to be deleting. */
1908 pjob->status = LPQ_DELETING;
1909 pjob_store(sharename, jobid, pjob);
1911 if (pjob->spooled && pjob->sysjob != -1)
1913 result = (*(current_printif->job_delete))(
1915 lp_lprmcommand(snum),
1918 /* Delete the tdb entry if the delete succeeded or the job hasn't
1922 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1927 pjob_delete(sharename, jobid);
1928 /* Ensure we keep a rough count of the number of total jobs... */
1929 tdb_change_int32_atomic(pdb->tdb, "INFO/total_jobs", &njobs, -1);
1930 release_print_db(pdb);
1934 remove_from_jobs_changed( sharename, jobid );
1936 return (result == 0);
1939 /****************************************************************************
1940 Return true if the current user owns the print job.
1941 ****************************************************************************/
1943 static BOOL is_owner(struct current_user *user, const char *servicename,
1946 struct printjob *pjob = print_job_find(servicename, jobid);
1952 if ((vuser = get_valid_user_struct(user->vuid)) != NULL) {
1953 return strequal(pjob->user, vuser->user.smb_name);
1955 return strequal(pjob->user, uidtoname(user->ut.uid));
1959 /****************************************************************************
1961 ****************************************************************************/
1963 BOOL print_job_delete(struct current_user *user, int snum, uint32 jobid, WERROR *errcode)
1965 const char* sharename = lp_const_servicename( snum );
1966 struct printjob *pjob;
1972 owner = is_owner(user, lp_const_servicename(snum), jobid);
1974 /* Check access against security descriptor or whether the user
1978 !print_access_check(user, snum, JOB_ACCESS_ADMINISTER)) {
1979 DEBUG(3, ("delete denied by security descriptor\n"));
1980 *errcode = WERR_ACCESS_DENIED;
1982 /* BEGIN_ADMIN_LOG */
1983 sys_adminlog( LOG_ERR,
1984 "Permission denied-- user not allowed to delete, \
1985 pause, or resume print job. User name: %s. Printer name: %s.",
1986 uidtoname(user->ut.uid), PRINTERNAME(snum) );
1993 * get the spooled filename of the print job
1994 * if this works, then the file has not been spooled
1995 * to the underlying print system. Just delete the
1996 * spool file & return.
1999 if ( (fname = print_job_fname( sharename, jobid )) != NULL )
2001 /* remove the spool file */
2002 DEBUG(10,("print_job_delete: Removing spool file [%s]\n", fname ));
2003 if ( unlink( fname ) == -1 ) {
2004 *errcode = map_werror_from_unix(errno);
2009 if (!print_job_delete1(snum, jobid)) {
2010 *errcode = WERR_ACCESS_DENIED;
2014 /* force update the database and say the delete failed if the
2017 print_queue_update(snum, True);
2019 pjob = print_job_find(sharename, jobid);
2020 if ( pjob && (pjob->status != LPQ_DELETING) )
2021 *errcode = WERR_ACCESS_DENIED;
2023 return (pjob == NULL );
2026 /****************************************************************************
2028 ****************************************************************************/
2030 BOOL print_job_pause(struct current_user *user, int snum, uint32 jobid, WERROR *errcode)
2032 const char* sharename = lp_const_servicename(snum);
2033 struct printjob *pjob;
2035 struct printif *current_printif = get_printer_fns( snum );
2037 pjob = print_job_find(sharename, jobid);
2039 if (!pjob || !user) {
2040 DEBUG(10, ("print_job_pause: no pjob or user for jobid %u\n",
2041 (unsigned int)jobid ));
2045 if (!pjob->spooled || pjob->sysjob == -1) {
2046 DEBUG(10, ("print_job_pause: not spooled or bad sysjob = %d for jobid %u\n",
2047 (int)pjob->sysjob, (unsigned int)jobid ));
2051 if (!is_owner(user, lp_const_servicename(snum), jobid) &&
2052 !print_access_check(user, snum, JOB_ACCESS_ADMINISTER)) {
2053 DEBUG(3, ("pause denied by security descriptor\n"));
2055 /* BEGIN_ADMIN_LOG */
2056 sys_adminlog( LOG_ERR,
2057 "Permission denied-- user not allowed to delete, \
2058 pause, or resume print job. User name: %s. Printer name: %s.",
2059 uidtoname(user->ut.uid), PRINTERNAME(snum) );
2062 *errcode = WERR_ACCESS_DENIED;
2066 /* need to pause the spooled entry */
2067 ret = (*(current_printif->job_pause))(snum, pjob);
2070 *errcode = WERR_INVALID_PARAM;
2074 /* force update the database */
2075 print_cache_flush(lp_const_servicename(snum));
2077 /* Send a printer notify message */
2079 notify_job_status(sharename, jobid, JOB_STATUS_PAUSED);
2081 /* how do we tell if this succeeded? */
2086 /****************************************************************************
2088 ****************************************************************************/
2090 BOOL print_job_resume(struct current_user *user, int snum, uint32 jobid, WERROR *errcode)
2092 const char *sharename = lp_const_servicename(snum);
2093 struct printjob *pjob;
2095 struct printif *current_printif = get_printer_fns( snum );
2097 pjob = print_job_find(sharename, jobid);
2099 if (!pjob || !user) {
2100 DEBUG(10, ("print_job_resume: no pjob or user for jobid %u\n",
2101 (unsigned int)jobid ));
2105 if (!pjob->spooled || pjob->sysjob == -1) {
2106 DEBUG(10, ("print_job_resume: not spooled or bad sysjob = %d for jobid %u\n",
2107 (int)pjob->sysjob, (unsigned int)jobid ));
2111 if (!is_owner(user, lp_const_servicename(snum), jobid) &&
2112 !print_access_check(user, snum, JOB_ACCESS_ADMINISTER)) {
2113 DEBUG(3, ("resume denied by security descriptor\n"));
2114 *errcode = WERR_ACCESS_DENIED;
2116 /* BEGIN_ADMIN_LOG */
2117 sys_adminlog( LOG_ERR,
2118 "Permission denied-- user not allowed to delete, \
2119 pause, or resume print job. User name: %s. Printer name: %s.",
2120 uidtoname(user->ut.uid), PRINTERNAME(snum) );
2125 ret = (*(current_printif->job_resume))(snum, pjob);
2128 *errcode = WERR_INVALID_PARAM;
2132 /* force update the database */
2133 print_cache_flush(lp_const_servicename(snum));
2135 /* Send a printer notify message */
2137 notify_job_status(sharename, jobid, JOB_STATUS_QUEUED);
2142 /****************************************************************************
2143 Write to a print file.
2144 ****************************************************************************/
2146 ssize_t print_job_write(int snum, uint32 jobid, const char *buf, SMB_OFF_T pos, size_t size)
2148 const char* sharename = lp_const_servicename(snum);
2150 struct printjob *pjob;
2152 pjob = print_job_find(sharename, jobid);
2156 /* don't allow another process to get this info - it is meaningless */
2157 if (pjob->pid != sys_getpid())
2160 return_code = write_data_at_offset(pjob->fd, buf, size, pos);
2162 if (return_code>0) {
2164 pjob_store(sharename, jobid, pjob);
2169 /****************************************************************************
2170 Get the queue status - do not update if db is out of date.
2171 ****************************************************************************/
2173 static int get_queue_status(const char* sharename, print_status_struct *status)
2177 struct tdb_print_db *pdb = get_print_db_byname(sharename);
2181 ZERO_STRUCTP(status);
2188 fstr_sprintf(keystr, "STATUS/%s", sharename);
2189 data = tdb_fetch(pdb->tdb, string_tdb_data(keystr));
2191 if (data.dsize == sizeof(print_status_struct))
2192 /* this memcpy is ok since the status struct was
2193 not packed before storing it in the tdb */
2194 memcpy(status, data.dptr, sizeof(print_status_struct));
2195 SAFE_FREE(data.dptr);
2198 len = tdb_fetch_int32(pdb->tdb, "INFO/total_jobs");
2199 release_print_db(pdb);
2200 return (len == -1 ? 0 : len);
2203 /****************************************************************************
2204 Determine the number of jobs in a queue.
2205 ****************************************************************************/
2207 int print_queue_length(int snum, print_status_struct *pstatus)
2209 const char* sharename = lp_const_servicename( snum );
2210 print_status_struct status;
2213 ZERO_STRUCT( status );
2215 /* make sure the database is up to date */
2216 if (print_cache_expired(lp_const_servicename(snum), True))
2217 print_queue_update(snum, False);
2219 /* also fetch the queue status */
2220 memset(&status, 0, sizeof(status));
2221 len = get_queue_status(sharename, &status);
2229 /***************************************************************************
2230 Allocate a jobid. Hold the lock for as short a time as possible.
2231 ***************************************************************************/
2233 static BOOL allocate_print_jobid(struct tdb_print_db *pdb, int snum, const char *sharename, uint32 *pjobid)
2238 *pjobid = (uint32)-1;
2240 for (i = 0; i < 3; i++) {
2241 /* Lock the database - only wait 20 seconds. */
2242 if (tdb_lock_bystring_with_timeout(pdb->tdb, "INFO/nextjob", 20) == -1) {
2243 DEBUG(0,("allocate_print_jobid: failed to lock printing database %s\n", sharename));
2247 if (!tdb_fetch_uint32(pdb->tdb, "INFO/nextjob", &jobid)) {
2248 if (tdb_error(pdb->tdb) != TDB_ERR_NOEXIST) {
2249 DEBUG(0, ("allocate_print_jobid: failed to fetch INFO/nextjob for print queue %s\n",
2256 jobid = NEXT_JOBID(jobid);
2258 if (tdb_store_int32(pdb->tdb, "INFO/nextjob", jobid)==-1) {
2259 DEBUG(3, ("allocate_print_jobid: failed to store INFO/nextjob.\n"));
2260 tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
2264 /* We've finished with the INFO/nextjob lock. */
2265 tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
2267 if (!print_job_exists(sharename, jobid))
2272 DEBUG(0, ("allocate_print_jobid: failed to allocate a print job for queue %s\n",
2274 /* Probably full... */
2279 /* Store a dummy placeholder. */
2284 if (tdb_store(pdb->tdb, print_key(jobid), dum, TDB_INSERT) == -1) {
2285 DEBUG(3, ("allocate_print_jobid: jobid (%d) failed to store placeholder.\n",
2295 /***************************************************************************
2296 Append a jobid to the 'jobs changed' list.
2297 ***************************************************************************/
2299 static BOOL add_to_jobs_changed(struct tdb_print_db *pdb, uint32 jobid)
2304 SIVAL(&store_jobid, 0, jobid);
2305 data.dptr = (uint8 *)&store_jobid;
2308 DEBUG(10,("add_to_jobs_changed: Added jobid %u\n", (unsigned int)jobid ));
2310 return (tdb_append(pdb->tdb, string_tdb_data("INFO/jobs_changed"),
2314 /***************************************************************************
2315 Start spooling a job - return the jobid.
2316 ***************************************************************************/
2318 uint32 print_job_start(struct current_user *user, int snum, char *jobname, NT_DEVICEMODE *nt_devmode )
2322 struct printjob pjob;
2324 const char *sharename = lp_const_servicename(snum);
2325 struct tdb_print_db *pdb = get_print_db_byname(sharename);
2333 if (!print_access_check(user, snum, PRINTER_ACCESS_USE)) {
2334 DEBUG(3, ("print_job_start: job start denied by security descriptor\n"));
2335 release_print_db(pdb);
2339 if (!print_time_access_check(lp_servicename(snum))) {
2340 DEBUG(3, ("print_job_start: job start denied by time check\n"));
2341 release_print_db(pdb);
2345 path = lp_pathname(snum);
2347 /* see if we have sufficient disk space */
2348 if (lp_minprintspace(snum)) {
2349 SMB_BIG_UINT dspace, dsize;
2350 if (sys_fsusage(path, &dspace, &dsize) == 0 &&
2351 dspace < 2*(SMB_BIG_UINT)lp_minprintspace(snum)) {
2352 DEBUG(3, ("print_job_start: disk space check failed.\n"));
2353 release_print_db(pdb);
2359 /* for autoloaded printers, check that the printcap entry still exists */
2360 if (lp_autoloaded(snum) && !pcap_printername_ok(lp_const_servicename(snum))) {
2361 DEBUG(3, ("print_job_start: printer name %s check failed.\n", lp_const_servicename(snum) ));
2362 release_print_db(pdb);
2367 /* Insure the maximum queue size is not violated */
2368 if ((njobs = print_queue_length(snum,NULL)) > lp_maxprintjobs(snum)) {
2369 DEBUG(3, ("print_job_start: Queue %s number of jobs (%d) larger than max printjobs per queue (%d).\n",
2370 sharename, njobs, lp_maxprintjobs(snum) ));
2371 release_print_db(pdb);
2376 DEBUG(10,("print_job_start: Queue %s number of jobs (%d), max printjobs = %d\n",
2377 sharename, njobs, lp_maxprintjobs(snum) ));
2379 if (!allocate_print_jobid(pdb, snum, sharename, &jobid))
2382 /* create the database entry */
2386 pjob.pid = sys_getpid();
2389 pjob.starttime = time(NULL);
2390 pjob.status = LPQ_SPOOLING;
2392 pjob.spooled = False;
2394 pjob.nt_devmode = nt_devmode;
2396 fstrcpy(pjob.jobname, jobname);
2398 if ((vuser = get_valid_user_struct(user->vuid)) != NULL) {
2399 fstrcpy(pjob.user, lp_printjob_username(snum));
2400 standard_sub_basic(vuser->user.smb_name, vuser->user.domain,
2401 pjob.user, sizeof(pjob.user)-1);
2402 /* ensure NULL termination */
2403 pjob.user[sizeof(pjob.user)-1] = '\0';
2405 fstrcpy(pjob.user, uidtoname(user->ut.uid));
2408 fstrcpy(pjob.queuename, lp_const_servicename(snum));
2410 /* we have a job entry - now create the spool file */
2411 slprintf(pjob.filename, sizeof(pjob.filename)-1, "%s/%s%.8u.XXXXXX",
2412 path, PRINT_SPOOL_PREFIX, (unsigned int)jobid);
2413 pjob.fd = smb_mkstemp(pjob.filename);
2415 if (pjob.fd == -1) {
2416 if (errno == EACCES) {
2417 /* Common setup error, force a report. */
2418 DEBUG(0, ("print_job_start: insufficient permissions \
2419 to open spool file %s.\n", pjob.filename));
2421 /* Normal case, report at level 3 and above. */
2422 DEBUG(3, ("print_job_start: can't open spool file %s,\n", pjob.filename));
2423 DEBUGADD(3, ("errno = %d (%s).\n", errno, strerror(errno)));
2428 pjob_store(sharename, jobid, &pjob);
2430 /* Update the 'jobs changed' entry used by print_queue_status. */
2431 add_to_jobs_changed(pdb, jobid);
2433 /* Ensure we keep a rough count of the number of total jobs... */
2434 tdb_change_int32_atomic(pdb->tdb, "INFO/total_jobs", &njobs, 1);
2436 release_print_db(pdb);
2442 pjob_delete(sharename, jobid);
2444 release_print_db(pdb);
2446 DEBUG(3, ("print_job_start: returning fail. Error = %s\n", strerror(errno) ));
2450 /****************************************************************************
2451 Update the number of pages spooled to jobid
2452 ****************************************************************************/
2454 void print_job_endpage(int snum, uint32 jobid)
2456 const char* sharename = lp_const_servicename(snum);
2457 struct printjob *pjob;
2459 pjob = print_job_find(sharename, jobid);
2462 /* don't allow another process to get this info - it is meaningless */
2463 if (pjob->pid != sys_getpid())
2467 pjob_store(sharename, jobid, pjob);
2470 /****************************************************************************
2471 Print a file - called on closing the file. This spools the job.
2472 If normal close is false then we're tearing down the jobs - treat as an
2474 ****************************************************************************/
2476 BOOL print_job_end(int snum, uint32 jobid, enum file_close_type close_type)
2478 const char* sharename = lp_const_servicename(snum);
2479 struct printjob *pjob;
2481 SMB_STRUCT_STAT sbuf;
2482 struct printif *current_printif = get_printer_fns( snum );
2484 pjob = print_job_find(sharename, jobid);
2489 if (pjob->spooled || pjob->pid != sys_getpid())
2492 if ((close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) &&
2493 (sys_fstat(pjob->fd, &sbuf) == 0)) {
2494 pjob->size = sbuf.st_size;
2500 * Not a normal close or we couldn't stat the job file,
2501 * so something has gone wrong. Cleanup.
2505 DEBUG(3,("print_job_end: failed to stat file for jobid %d\n", jobid ));
2509 /* Technically, this is not quite right. If the printer has a separator
2510 * page turned on, the NT spooler prints the separator page even if the
2511 * print job is 0 bytes. 010215 JRR */
2512 if (pjob->size == 0 || pjob->status == LPQ_DELETING) {
2513 /* don't bother spooling empty files or something being deleted. */
2514 DEBUG(5,("print_job_end: canceling spool of %s (%s)\n",
2515 pjob->filename, pjob->size ? "deleted" : "zero length" ));
2516 unlink(pjob->filename);
2517 pjob_delete(sharename, jobid);
2521 pjob->smbjob = jobid;
2523 ret = (*(current_printif->job_submit))(snum, pjob);
2528 /* The print job has been sucessfully handed over to the back-end */
2530 pjob->spooled = True;
2531 pjob->status = LPQ_QUEUED;
2532 pjob_store(sharename, jobid, pjob);
2534 /* make sure the database is up to date */
2535 if (print_cache_expired(lp_const_servicename(snum), True))
2536 print_queue_update(snum, False);
2542 /* The print job was not succesfully started. Cleanup */
2543 /* Still need to add proper error return propagation! 010122:JRR */
2544 unlink(pjob->filename);
2545 pjob_delete(sharename, jobid);
2549 /****************************************************************************
2550 Get a snapshot of jobs in the system without traversing.
2551 ****************************************************************************/
2553 static BOOL get_stored_queue_info(struct tdb_print_db *pdb, int snum, int *pcount, print_queue_struct **ppqueue)
2555 TDB_DATA data, cgdata;
2556 print_queue_struct *queue = NULL;
2558 uint32 extra_count = 0;
2559 int total_count = 0;
2562 int max_reported_jobs = lp_max_reported_jobs(snum);
2564 const char* sharename = lp_servicename(snum);
2566 /* make sure the database is up to date */
2567 if (print_cache_expired(lp_const_servicename(snum), True))
2568 print_queue_update(snum, False);
2574 ZERO_STRUCT(cgdata);
2576 /* Get the stored queue data. */
2577 data = tdb_fetch(pdb->tdb, string_tdb_data("INFO/linear_queue_array"));
2579 if (data.dptr && data.dsize >= sizeof(qcount))
2580 len += tdb_unpack(data.dptr + len, data.dsize - len, "d", &qcount);
2582 /* Get the changed jobs list. */
2583 cgdata = tdb_fetch(pdb->tdb, string_tdb_data("INFO/jobs_changed"));
2584 if (cgdata.dptr != NULL && (cgdata.dsize % 4 == 0))
2585 extra_count = cgdata.dsize/4;
2587 DEBUG(5,("get_stored_queue_info: qcount = %u, extra_count = %u\n", (unsigned int)qcount, (unsigned int)extra_count));
2589 /* Allocate the queue size. */
2590 if (qcount == 0 && extra_count == 0)
2593 if ((queue = SMB_MALLOC_ARRAY(print_queue_struct, qcount + extra_count)) == NULL)
2596 /* Retrieve the linearised queue data. */
2598 for( i = 0; i < qcount; i++) {
2599 uint32 qjob, qsize, qpage_count, qstatus, qpriority, qtime;
2600 len += tdb_unpack(data.dptr + len, data.dsize - len, "ddddddff",
2609 queue[i].job = qjob;
2610 queue[i].size = qsize;
2611 queue[i].page_count = qpage_count;
2612 queue[i].status = qstatus;
2613 queue[i].priority = qpriority;
2614 queue[i].time = qtime;
2617 total_count = qcount;
2619 /* Add in the changed jobids. */
2620 for( i = 0; i < extra_count; i++) {
2622 struct printjob *pjob;
2624 jobid = IVAL(cgdata.dptr, i*4);
2625 DEBUG(5,("get_stored_queue_info: changed job = %u\n", (unsigned int)jobid));
2626 pjob = print_job_find(lp_const_servicename(snum), jobid);
2628 DEBUG(5,("get_stored_queue_info: failed to find changed job = %u\n", (unsigned int)jobid));
2629 remove_from_jobs_changed(sharename, jobid);
2633 queue[total_count].job = jobid;
2634 queue[total_count].size = pjob->size;
2635 queue[total_count].page_count = pjob->page_count;
2636 queue[total_count].status = pjob->status;
2637 queue[total_count].priority = 1;
2638 queue[total_count].time = pjob->starttime;
2639 fstrcpy(queue[total_count].fs_user, pjob->user);
2640 fstrcpy(queue[total_count].fs_file, pjob->jobname);
2644 /* Sort the queue by submission time otherwise they are displayed
2647 qsort(queue, total_count, sizeof(print_queue_struct), QSORT_CAST(printjob_comp));
2649 DEBUG(5,("get_stored_queue_info: total_count = %u\n", (unsigned int)total_count));
2651 if (max_reported_jobs && total_count > max_reported_jobs)
2652 total_count = max_reported_jobs;
2655 *pcount = total_count;
2661 SAFE_FREE(data.dptr);
2662 SAFE_FREE(cgdata.dptr);
2666 /****************************************************************************
2667 Get a printer queue listing.
2668 set queue = NULL and status = NULL if you just want to update the cache
2669 ****************************************************************************/
2671 int print_queue_status(int snum,
2672 print_queue_struct **ppqueue,
2673 print_status_struct *status)
2677 const char *sharename;
2678 struct tdb_print_db *pdb;
2681 /* make sure the database is up to date */
2683 if (print_cache_expired(lp_const_servicename(snum), True))
2684 print_queue_update(snum, False);
2686 /* return if we are done */
2687 if ( !ppqueue || !status )
2691 sharename = lp_const_servicename(snum);
2692 pdb = get_print_db_byname(sharename);
2698 * Fetch the queue status. We must do this first, as there may
2699 * be no jobs in the queue.
2702 ZERO_STRUCTP(status);
2703 slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", sharename);
2704 key = string_tdb_data(keystr);
2706 data = tdb_fetch(pdb->tdb, key);
2708 if (data.dsize == sizeof(*status)) {
2709 /* this memcpy is ok since the status struct was
2710 not packed before storing it in the tdb */
2711 memcpy(status, data.dptr, sizeof(*status));
2713 SAFE_FREE(data.dptr);
2717 * Now, fetch the print queue information. We first count the number
2718 * of entries, and then only retrieve the queue if necessary.
2721 if (!get_stored_queue_info(pdb, snum, &count, ppqueue)) {
2722 release_print_db(pdb);
2726 release_print_db(pdb);
2730 /****************************************************************************
2732 ****************************************************************************/
2734 BOOL print_queue_pause(struct current_user *user, int snum, WERROR *errcode)
2737 struct printif *current_printif = get_printer_fns( snum );
2739 if (!print_access_check(user, snum, PRINTER_ACCESS_ADMINISTER)) {
2740 *errcode = WERR_ACCESS_DENIED;
2747 ret = (*(current_printif->queue_pause))(snum);
2752 *errcode = WERR_INVALID_PARAM;
2756 /* force update the database */
2757 print_cache_flush(lp_const_servicename(snum));
2759 /* Send a printer notify message */
2761 notify_printer_status(snum, PRINTER_STATUS_PAUSED);
2766 /****************************************************************************
2768 ****************************************************************************/
2770 BOOL print_queue_resume(struct current_user *user, int snum, WERROR *errcode)
2773 struct printif *current_printif = get_printer_fns( snum );
2775 if (!print_access_check(user, snum, PRINTER_ACCESS_ADMINISTER)) {
2776 *errcode = WERR_ACCESS_DENIED;
2782 ret = (*(current_printif->queue_resume))(snum);
2787 *errcode = WERR_INVALID_PARAM;
2791 /* make sure the database is up to date */
2792 if (print_cache_expired(lp_const_servicename(snum), True))
2793 print_queue_update(snum, True);
2795 /* Send a printer notify message */
2797 notify_printer_status(snum, PRINTER_STATUS_OK);
2802 /****************************************************************************
2803 Purge a queue - implemented by deleting all jobs that we can delete.
2804 ****************************************************************************/
2806 BOOL print_queue_purge(struct current_user *user, int snum, WERROR *errcode)
2808 print_queue_struct *queue;
2809 print_status_struct status;
2813 /* Force and update so the count is accurate (i.e. not a cached count) */
2814 print_queue_update(snum, True);
2816 can_job_admin = print_access_check(user, snum, JOB_ACCESS_ADMINISTER);
2817 njobs = print_queue_status(snum, &queue, &status);
2819 if ( can_job_admin )
2822 for (i=0;i<njobs;i++) {
2823 BOOL owner = is_owner(user, lp_const_servicename(snum), queue[i].job);
2825 if (owner || can_job_admin) {
2826 print_job_delete1(snum, queue[i].job);
2830 if ( can_job_admin )
2833 /* update the cache */
2834 print_queue_update( snum, True );