2 Unix SMB/Netbios implementation.
4 printing backend routines
5 Copyright (C) Andrew Tridgell 1992-2000
6 Copyright (C) Jeremy Allison 2002
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 extern SIG_ATOMIC_T got_sig_term;
27 extern SIG_ATOMIC_T reload_after_sighup;
29 /* Current printer interface */
30 static BOOL remove_from_jobs_changed(const char* sharename, uint32 jobid);
33 the printing backend revolves around a tdb database that stores the
34 SMB view of the print queue
36 The key for this database is a jobid - a internally generated number that
37 uniquely identifies a print job
39 reading the print queue involves two steps:
40 - possibly running lpq and updating the internal database from that
41 - reading entries from the database
43 jobids are assigned when a job starts spooling.
46 struct print_queue_update_context {
48 enum printing_types printing_type;
53 static TDB_CONTEXT *rap_tdb;
54 static uint16 next_rap_jobid;
55 struct rap_jobid_key {
60 /***************************************************************************
61 Nightmare. LANMAN jobid's are 16 bit numbers..... We must map them to 32
62 bit RPC jobids.... JRA.
63 ***************************************************************************/
65 uint16 pjobid_to_rap(const char* sharename, uint32 jobid)
69 struct rap_jobid_key jinfo;
71 DEBUG(10,("pjobid_to_rap: called.\n"));
74 /* Create the in-memory tdb. */
75 rap_tdb = tdb_open_log(NULL, 0, TDB_INTERNAL, (O_RDWR|O_CREAT), 0644);
81 fstrcpy( jinfo.sharename, sharename );
83 key.dptr = (char*)&jinfo;
84 key.dsize = sizeof(jinfo);
86 data = tdb_fetch(rap_tdb, key);
87 if (data.dptr && data.dsize == sizeof(uint16)) {
88 rap_jobid = SVAL(data.dptr, 0);
90 DEBUG(10,("pjobid_to_rap: jobid %u maps to RAP jobid %u\n",
91 (unsigned int)jobid, (unsigned int)rap_jobid));
95 /* Not found - create and store mapping. */
96 rap_jobid = ++next_rap_jobid;
98 rap_jobid = ++next_rap_jobid;
99 data.dptr = (char *)&rap_jobid;
100 data.dsize = sizeof(rap_jobid);
101 tdb_store(rap_tdb, key, data, TDB_REPLACE);
102 tdb_store(rap_tdb, data, key, TDB_REPLACE);
104 DEBUG(10,("pjobid_to_rap: created jobid %u maps to RAP jobid %u\n",
105 (unsigned int)jobid, (unsigned int)rap_jobid));
109 BOOL rap_to_pjobid(uint16 rap_jobid, fstring sharename, uint32 *pjobid)
113 DEBUG(10,("rap_to_pjobid called.\n"));
118 key.dptr = (char *)&rap_jobid;
119 key.dsize = sizeof(rap_jobid);
120 data = tdb_fetch(rap_tdb, key);
121 if ( data.dptr && data.dsize == sizeof(struct rap_jobid_key) )
123 struct rap_jobid_key *jinfo = (struct rap_jobid_key*)data.dptr;
124 fstrcpy( sharename, jinfo->sharename );
125 *pjobid = jinfo->jobid;
126 DEBUG(10,("rap_to_pjobid: jobid %u maps to RAP jobid %u\n",
127 (unsigned int)*pjobid, (unsigned int)rap_jobid));
128 SAFE_FREE(data.dptr);
132 DEBUG(10,("rap_to_pjobid: Failed to lookup RAP jobid %u\n",
133 (unsigned int)rap_jobid));
134 SAFE_FREE(data.dptr);
138 static void rap_jobid_delete(const char* sharename, uint32 jobid)
142 struct rap_jobid_key jinfo;
144 DEBUG(10,("rap_jobid_delete: called.\n"));
149 ZERO_STRUCT( jinfo );
150 fstrcpy( jinfo.sharename, sharename );
152 key.dptr = (char*)&jinfo;
153 key.dsize = sizeof(jinfo);
155 data = tdb_fetch(rap_tdb, key);
156 if (!data.dptr || (data.dsize != sizeof(uint16))) {
157 DEBUG(10,("rap_jobid_delete: cannot find jobid %u\n",
158 (unsigned int)jobid ));
159 SAFE_FREE(data.dptr);
163 DEBUG(10,("rap_jobid_delete: deleting jobid %u\n",
164 (unsigned int)jobid ));
166 rap_jobid = SVAL(data.dptr, 0);
167 SAFE_FREE(data.dptr);
168 data.dptr = (char *)&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(void)
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, 0) == -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();
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 */
248 printer_fns->type = type;
253 static struct printif *get_printer_fns( int snum )
255 return get_printer_fns_from_type( lp_printing(snum) );
259 /****************************************************************************
260 Useful function to generate a tdb key.
261 ****************************************************************************/
263 static TDB_DATA print_key(uint32 jobid)
269 ret.dptr = (void *)&j;
270 ret.dsize = sizeof(j);
274 /***********************************************************************
275 unpack a pjob from a tdb buffer
276 ***********************************************************************/
278 int unpack_pjob( char* buf, int buflen, struct printjob *pjob )
282 uint32 pjpid, pjsysjob, pjfd, pjstarttime, pjstatus;
283 uint32 pjsize, pjpage_count, pjspooled, pjsmbjob;
288 len += tdb_unpack(buf+len, buflen-len, "dddddddddffff",
306 if ( (used = unpack_devicemode(&pjob->nt_devmode, buf+len, buflen-len)) == -1 )
312 pjob->sysjob = pjsysjob;
314 pjob->starttime = pjstarttime;
315 pjob->status = pjstatus;
317 pjob->page_count = pjpage_count;
318 pjob->spooled = pjspooled;
319 pjob->smbjob = pjsmbjob;
325 /****************************************************************************
326 Useful function to find a print job in the database.
327 ****************************************************************************/
329 static struct printjob *print_job_find(const char *sharename, uint32 jobid)
331 static struct printjob pjob;
333 struct tdb_print_db *pdb = get_print_db_byname(sharename);
339 ret = tdb_fetch(pdb->tdb, print_key(jobid));
340 release_print_db(pdb);
345 if ( pjob.nt_devmode )
346 free_nt_devicemode( &pjob.nt_devmode );
350 if ( unpack_pjob( ret.dptr, ret.dsize, &pjob ) == -1 ) {
359 /* Convert a unix jobid to a smb jobid */
361 static uint32 sysjob_to_jobid_value;
363 static int unixjob_traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA key,
364 TDB_DATA data, void *state)
366 struct printjob *pjob;
367 int *sysjob = (int *)state;
369 if (!data.dptr || data.dsize == 0)
372 pjob = (struct printjob *)data.dptr;
373 if (key.dsize != sizeof(uint32))
376 if (*sysjob == pjob->sysjob) {
377 uint32 jobid = IVAL(key.dptr,0);
379 sysjob_to_jobid_value = jobid;
386 /****************************************************************************
387 This is a *horribly expensive call as we have to iterate through all the
388 current printer tdb's. Don't do this often ! JRA.
389 ****************************************************************************/
391 uint32 sysjob_to_jobid(int unix_jobid)
393 int services = lp_numservices();
396 sysjob_to_jobid_value = (uint32)-1;
398 for (snum = 0; snum < services; snum++) {
399 struct tdb_print_db *pdb;
400 if (!lp_print_ok(snum))
402 pdb = get_print_db_byname(lp_const_servicename(snum));
404 tdb_traverse(pdb->tdb, unixjob_traverse_fn, &unix_jobid);
405 release_print_db(pdb);
406 if (sysjob_to_jobid_value != (uint32)-1)
407 return sysjob_to_jobid_value;
412 /****************************************************************************
413 Send notifications based on what has changed after a pjob_store.
414 ****************************************************************************/
418 uint32 spoolss_status;
419 } lpq_to_spoolss_status_map[] = {
420 { LPQ_QUEUED, JOB_STATUS_QUEUED },
421 { LPQ_PAUSED, JOB_STATUS_PAUSED },
422 { LPQ_SPOOLING, JOB_STATUS_SPOOLING },
423 { LPQ_PRINTING, JOB_STATUS_PRINTING },
424 { LPQ_DELETING, JOB_STATUS_DELETING },
425 { LPQ_OFFLINE, JOB_STATUS_OFFLINE },
426 { LPQ_PAPEROUT, JOB_STATUS_PAPEROUT },
427 { LPQ_PRINTED, JOB_STATUS_PRINTED },
428 { LPQ_DELETED, JOB_STATUS_DELETED },
429 { LPQ_BLOCKED, JOB_STATUS_BLOCKED },
430 { LPQ_USER_INTERVENTION, JOB_STATUS_USER_INTERVENTION },
434 /* Convert a lpq status value stored in printing.tdb into the
435 appropriate win32 API constant. */
437 static uint32 map_to_spoolss_status(uint32 lpq_status)
441 while (lpq_to_spoolss_status_map[i].lpq_status != -1) {
442 if (lpq_to_spoolss_status_map[i].lpq_status == lpq_status)
443 return lpq_to_spoolss_status_map[i].spoolss_status;
450 static void pjob_store_notify(const char* sharename, uint32 jobid, struct printjob *old_data,
451 struct printjob *new_data)
453 BOOL new_job = False;
458 /* Job attributes that can't be changed. We only send
459 notification for these on a new job. */
461 /* ACHTUNG! Due to a bug in Samba's spoolss parsing of the
462 NOTIFY_INFO_DATA buffer, we *have* to send the job submission
463 time first or else we'll end up with potential alignment
464 errors. I don't think the systemtime should be spooled as
465 a string, but this gets us around that error.
466 --jerry (i'll feel dirty for this) */
469 notify_job_submitted(sharename, jobid, new_data->starttime);
470 notify_job_username(sharename, jobid, new_data->user);
473 if (new_job || !strequal(old_data->jobname, new_data->jobname))
474 notify_job_name(sharename, jobid, new_data->jobname);
476 /* Job attributes of a new job or attributes that can be
479 if (new_job || !strequal(old_data->jobname, new_data->jobname))
480 notify_job_name(sharename, jobid, new_data->jobname);
482 if (new_job || old_data->status != new_data->status)
483 notify_job_status(sharename, jobid, map_to_spoolss_status(new_data->status));
485 if (new_job || old_data->size != new_data->size)
486 notify_job_total_bytes(sharename, jobid, new_data->size);
488 if (new_job || old_data->page_count != new_data->page_count)
489 notify_job_total_pages(sharename, jobid, new_data->page_count);
492 /****************************************************************************
493 Store a job structure back to the database.
494 ****************************************************************************/
496 static BOOL pjob_store(const char* sharename, uint32 jobid, struct printjob *pjob)
498 TDB_DATA old_data, new_data;
500 struct tdb_print_db *pdb = get_print_db_byname(sharename);
502 int len, newlen, buflen;
510 old_data = tdb_fetch(pdb->tdb, print_key(jobid));
512 /* Doh! Now we have to pack/unpack data since the NT_DEVICEMODE was added */
519 len += tdb_pack(buf+len, buflen-len, "dddddddddffff",
521 (uint32)pjob->sysjob,
523 (uint32)pjob->starttime,
524 (uint32)pjob->status,
526 (uint32)pjob->page_count,
527 (uint32)pjob->spooled,
528 (uint32)pjob->smbjob,
534 len += pack_devicemode(pjob->nt_devmode, buf+len, buflen-len);
539 tb = (char *)SMB_REALLOC(buf, len);
541 DEBUG(0,("pjob_store: failed to enlarge buffer!\n"));
548 } while ( buflen != len );
554 new_data.dsize = len;
555 ret = (tdb_store(pdb->tdb, print_key(jobid), new_data, TDB_REPLACE) == 0);
557 release_print_db(pdb);
559 /* Send notify updates for what has changed */
562 struct printjob old_pjob;
564 if ( old_data.dsize )
566 if ( unpack_pjob( old_data.dptr, old_data.dsize, &old_pjob ) != -1 )
568 pjob_store_notify( sharename, jobid, &old_pjob , pjob );
569 free_nt_devicemode( &old_pjob.nt_devmode );
574 pjob_store_notify( sharename, jobid, NULL, pjob );
579 SAFE_FREE( old_data.dptr );
585 /****************************************************************************
586 Remove a job structure from the database.
587 ****************************************************************************/
589 void pjob_delete(const char* sharename, uint32 jobid)
591 struct printjob *pjob;
592 uint32 job_status = 0;
593 struct tdb_print_db *pdb;
595 pdb = get_print_db_byname( sharename );
600 pjob = print_job_find( sharename, jobid );
603 DEBUG(5, ("pjob_delete: we were asked to delete nonexistent job %u\n",
604 (unsigned int)jobid));
605 release_print_db(pdb);
609 /* We must cycle through JOB_STATUS_DELETING and
610 JOB_STATUS_DELETED for the port monitor to delete the job
613 job_status = JOB_STATUS_DELETING|JOB_STATUS_DELETED;
614 notify_job_status(sharename, jobid, job_status);
616 /* Remove from printing.tdb */
618 tdb_delete(pdb->tdb, print_key(jobid));
619 remove_from_jobs_changed(sharename, jobid);
620 release_print_db( pdb );
621 rap_jobid_delete(sharename, jobid);
624 /****************************************************************************
625 Parse a file name from the system spooler to generate a jobid.
626 ****************************************************************************/
628 static uint32 print_parse_jobid(char *fname)
632 if (strncmp(fname,PRINT_SPOOL_PREFIX,strlen(PRINT_SPOOL_PREFIX)) != 0)
634 fname += strlen(PRINT_SPOOL_PREFIX);
640 return (uint32)jobid;
643 /****************************************************************************
644 List a unix job in the print database.
645 ****************************************************************************/
647 static void print_unix_job(const char *sharename, print_queue_struct *q, uint32 jobid)
649 struct printjob pj, *old_pj;
651 if (jobid == (uint32)-1)
652 jobid = q->job + UNIX_JOB_START;
654 /* Preserve the timestamp on an existing unix print job */
656 old_pj = print_job_find(sharename, jobid);
663 pj.starttime = old_pj ? old_pj->starttime : q->time;
664 pj.status = q->status;
667 fstrcpy(pj.filename, old_pj ? old_pj->filename : "");
668 if (jobid < UNIX_JOB_START) {
670 fstrcpy(pj.jobname, old_pj ? old_pj->jobname : "Remote Downlevel Document");
673 fstrcpy(pj.jobname, old_pj ? old_pj->jobname : q->fs_file);
675 fstrcpy(pj.user, old_pj ? old_pj->user : q->fs_user);
676 fstrcpy(pj.queuename, old_pj ? old_pj->queuename : sharename );
678 pjob_store(sharename, jobid, &pj);
682 struct traverse_struct {
683 print_queue_struct *queue;
684 int qcount, snum, maxcount, total_jobs;
685 const char *sharename;
689 /****************************************************************************
690 Utility fn to delete any jobs that are no longer active.
691 ****************************************************************************/
693 static int traverse_fn_delete(TDB_CONTEXT *t, TDB_DATA key, TDB_DATA data, void *state)
695 struct traverse_struct *ts = (struct traverse_struct *)state;
696 struct printjob pjob;
700 if ( key.dsize != sizeof(jobid) )
703 jobid = IVAL(key.dptr, 0);
704 if ( unpack_pjob( data.dptr, data.dsize, &pjob ) == -1 )
706 free_nt_devicemode( &pjob.nt_devmode );
710 /* remove a unix job if it isn't in the system queue any more */
712 for (i=0;i<ts->qcount;i++) {
713 uint32 u_jobid = (ts->queue[i].job + UNIX_JOB_START);
714 if (jobid == u_jobid)
717 if (i == ts->qcount) {
718 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !smbjob\n",
719 (unsigned int)jobid ));
720 pjob_delete(ts->sharename, jobid);
724 /* need to continue the the bottom of the function to
725 save the correct attributes */
728 /* maybe it hasn't been spooled yet */
730 /* if a job is not spooled and the process doesn't
731 exist then kill it. This cleans up after smbd
733 if (!process_exists(pjob.pid)) {
734 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !process_exists (%u)\n",
735 (unsigned int)jobid, (unsigned int)pjob.pid ));
736 pjob_delete(ts->sharename, jobid);
742 /* this check only makes sense for jobs submitted from Windows clients */
745 for (i=0;i<ts->qcount;i++) {
746 uint32 curr_jobid = print_parse_jobid(ts->queue[i].fs_file);
747 if (jobid == curr_jobid)
752 /* The job isn't in the system queue - we have to assume it has
753 completed, so delete the database entry. */
755 if (i == ts->qcount) {
757 /* A race can occur between the time a job is spooled and
758 when it appears in the lpq output. This happens when
759 the job is added to printing.tdb when another smbd
760 running print_queue_update() has completed a lpq and
761 is currently traversing the printing tdb and deleting jobs.
762 Don't delete the job if it was submitted after the lpq_time. */
764 if (pjob.starttime < ts->lpq_time) {
765 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to pjob.starttime (%u) < ts->lpq_time (%u)\n",
767 (unsigned int)pjob.starttime,
768 (unsigned int)ts->lpq_time ));
769 pjob_delete(ts->sharename, jobid);
775 /* Save the pjob attributes we will store. */
776 /* FIXME!!! This is the only place where queue->job
777 represents the SMB jobid --jerry */
778 ts->queue[i].job = jobid;
779 ts->queue[i].size = pjob.size;
780 ts->queue[i].page_count = pjob.page_count;
781 ts->queue[i].status = pjob.status;
782 ts->queue[i].priority = 1;
783 ts->queue[i].time = pjob.starttime;
784 fstrcpy(ts->queue[i].fs_user, pjob.user);
785 fstrcpy(ts->queue[i].fs_file, pjob.jobname);
792 /****************************************************************************
793 Check if the print queue has been updated recently enough.
794 ****************************************************************************/
796 static void print_cache_flush(int snum)
799 const char *sharename = lp_const_servicename(snum);
800 struct tdb_print_db *pdb = get_print_db_byname(sharename);
804 slprintf(key, sizeof(key)-1, "CACHE/%s", sharename);
805 tdb_store_int32(pdb->tdb, key, -1);
806 release_print_db(pdb);
809 /****************************************************************************
810 Check if someone already thinks they are doing the update.
811 ****************************************************************************/
813 static pid_t get_updating_pid(fstring sharename)
818 struct tdb_print_db *pdb = get_print_db_byname(sharename);
822 slprintf(keystr, sizeof(keystr)-1, "UPDATING/%s", sharename);
824 key.dsize = strlen(keystr);
826 data = tdb_fetch(pdb->tdb, key);
827 release_print_db(pdb);
828 if (!data.dptr || data.dsize != sizeof(pid_t)) {
829 SAFE_FREE(data.dptr);
833 updating_pid = IVAL(data.dptr, 0);
834 SAFE_FREE(data.dptr);
836 if (process_exists(updating_pid))
842 /****************************************************************************
843 Set the fact that we're doing the update, or have finished doing the update
845 ****************************************************************************/
847 static void set_updating_pid(const fstring sharename, BOOL updating)
852 pid_t updating_pid = sys_getpid();
855 struct tdb_print_db *pdb = get_print_db_byname(sharename);
860 slprintf(keystr, sizeof(keystr)-1, "UPDATING/%s", sharename);
862 key.dsize = strlen(keystr);
864 DEBUG(5, ("set_updating_pid: %s updating lpq cache for print share %s\n",
865 updating ? "" : "not ",
869 tdb_delete(pdb->tdb, key);
870 release_print_db(pdb);
874 SIVAL( buffer, 0, updating_pid);
875 data.dptr = (void *)buffer;
876 data.dsize = 4; /* we always assume this is a 4 byte value */
878 tdb_store(pdb->tdb, key, data, TDB_REPLACE);
879 release_print_db(pdb);
882 /****************************************************************************
883 Sort print jobs by submittal time.
884 ****************************************************************************/
886 static int printjob_comp(print_queue_struct *j1, print_queue_struct *j2)
897 /* Sort on job start time */
899 if (j1->time == j2->time)
901 return (j1->time > j2->time) ? 1 : -1;
904 /****************************************************************************
905 Store the sorted queue representation for later portmon retrieval.
906 ****************************************************************************/
908 static void store_queue_struct(struct tdb_print_db *pdb, struct traverse_struct *pts)
911 int max_reported_jobs = lp_max_reported_jobs(pts->snum);
912 print_queue_struct *queue = pts->queue;
917 if (max_reported_jobs && (max_reported_jobs < pts->qcount))
918 pts->qcount = max_reported_jobs;
919 qcount = pts->qcount;
921 /* Work out the size. */
923 data.dsize += tdb_pack(NULL, 0, "d", qcount);
925 for (i = 0; i < pts->qcount; i++) {
926 data.dsize += tdb_pack(NULL, 0, "ddddddff",
927 (uint32)queue[i].job,
928 (uint32)queue[i].size,
929 (uint32)queue[i].page_count,
930 (uint32)queue[i].status,
931 (uint32)queue[i].priority,
932 (uint32)queue[i].time,
937 if ((data.dptr = SMB_MALLOC(data.dsize)) == NULL)
941 len += tdb_pack(data.dptr + len, data.dsize - len, "d", qcount);
942 for (i = 0; i < pts->qcount; i++) {
943 len += tdb_pack(data.dptr + len, data.dsize - len, "ddddddff",
944 (uint32)queue[i].job,
945 (uint32)queue[i].size,
946 (uint32)queue[i].page_count,
947 (uint32)queue[i].status,
948 (uint32)queue[i].priority,
949 (uint32)queue[i].time,
954 key.dptr = "INFO/linear_queue_array";
955 key.dsize = strlen(key.dptr);
956 tdb_store(pdb->tdb, key, data, TDB_REPLACE);
957 SAFE_FREE(data.dptr);
961 static TDB_DATA get_jobs_changed_data(struct tdb_print_db *pdb)
965 key.dptr = "INFO/jobs_changed";
966 key.dsize = strlen(key.dptr);
969 data = tdb_fetch(pdb->tdb, key);
970 if (data.dptr == NULL || data.dsize == 0 || (data.dsize % 4 != 0)) {
971 SAFE_FREE(data.dptr);
978 static void check_job_changed(const char *sharename, TDB_DATA data, uint32 jobid)
981 unsigned int job_count = data.dsize / 4;
983 for (i = 0; i < job_count; i++) {
986 ch_jobid = IVAL(data.dptr, i*4);
987 if (ch_jobid == jobid)
988 remove_from_jobs_changed(sharename, jobid);
992 /****************************************************************************
993 Check if the print queue has been updated recently enough.
994 ****************************************************************************/
996 static BOOL print_cache_expired(const char *sharename)
999 time_t last_qscan_time, time_now = time(NULL);
1000 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1005 slprintf(key, sizeof(key), "CACHE/%s", sharename);
1006 last_qscan_time = (time_t)tdb_fetch_int32(pdb->tdb, key);
1009 * Invalidate the queue for 3 reasons.
1010 * (1). last queue scan time == -1.
1011 * (2). Current time - last queue scan time > allowed cache time.
1012 * (3). last queue scan time > current time + MAX_CACHE_VALID_TIME (1 hour by default).
1013 * This last test picks up machines for which the clock has been moved
1014 * forward, an lpq scan done and then the clock moved back. Otherwise
1015 * that last lpq scan would stay around for a loooong loooong time... :-). JRA.
1018 if (last_qscan_time == ((time_t)-1)
1019 || (time_now - last_qscan_time) >= lp_lpqcachetime()
1020 || last_qscan_time > (time_now + MAX_CACHE_VALID_TIME))
1022 DEBUG(3, ("print cache expired for queue %s "
1023 "(last_qscan_time = %d, time now = %d, qcachetime = %d)\n",
1024 sharename, (int)last_qscan_time, (int)time_now,
1025 (int)lp_lpqcachetime() ));
1026 release_print_db(pdb);
1029 release_print_db(pdb);
1033 /****************************************************************************
1034 main work for updating the lpq cahe for a printer queue
1035 ****************************************************************************/
1037 static void print_queue_update_internal( const char *sharename,
1038 struct printif *current_printif,
1042 print_queue_struct *queue = NULL;
1043 print_status_struct status;
1044 print_status_struct old_status;
1045 struct printjob *pjob;
1046 struct traverse_struct tstruct;
1049 fstring keystr, cachestr;
1050 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1052 DEBUG(5,("print_queue_update_internal: printer = %s, type = %d, lpq command = [%s]\n",
1053 sharename, current_printif->type, lpq_command));
1055 if ( !print_cache_expired(sharename) ) {
1056 DEBUG(5,("print_queue_update_internal: print cache for %s is still ok\n", sharename));
1061 * Update the cache time FIRST ! Stops others even
1062 * attempting to get the lock and doing this
1063 * if the lpq takes a long time.
1066 slprintf(cachestr, sizeof(cachestr)-1, "CACHE/%s", sharename);
1067 tdb_store_int32(pdb->tdb, cachestr, (int)time(NULL));
1069 /* get the current queue using the appropriate interface */
1070 ZERO_STRUCT(status);
1072 qcount = (*(current_printif->queue_get))(sharename,
1073 current_printif->type,
1074 lpq_command, &queue, &status);
1076 DEBUG(3, ("print_queue_update_internal: %d job%s in queue for %s\n",
1077 qcount, (qcount != 1) ? "s" : "", sharename));
1079 /* Sort the queue by submission time otherwise they are displayed
1082 qsort(queue, qcount, sizeof(print_queue_struct),
1083 QSORT_CAST(printjob_comp));
1086 any job in the internal database that is marked as spooled
1087 and doesn't exist in the system queue is considered finished
1088 and removed from the database
1090 any job in the system database but not in the internal database
1091 is added as a unix job
1093 fill in any system job numbers as we go
1096 jcdata = get_jobs_changed_data(pdb);
1098 for (i=0; i<qcount; i++) {
1099 uint32 jobid = print_parse_jobid(queue[i].fs_file);
1101 if (jobid == (uint32)-1) {
1102 /* assume its a unix print job */
1103 print_unix_job(sharename, &queue[i], jobid);
1107 /* we have an active SMB print job - update its status */
1108 pjob = print_job_find(sharename, jobid);
1110 /* err, somethings wrong. Probably smbd was restarted
1111 with jobs in the queue. All we can do is treat them
1112 like unix jobs. Pity. */
1113 print_unix_job(sharename, &queue[i], jobid);
1117 pjob->sysjob = queue[i].job;
1118 pjob->status = queue[i].status;
1119 pjob_store(sharename, jobid, pjob);
1120 check_job_changed(sharename, jcdata, jobid);
1123 SAFE_FREE(jcdata.dptr);
1125 /* now delete any queued entries that don't appear in the
1127 tstruct.queue = queue;
1128 tstruct.qcount = qcount;
1130 tstruct.total_jobs = 0;
1131 tstruct.lpq_time = time(NULL);
1132 tstruct.sharename = sharename;
1134 tdb_traverse(pdb->tdb, traverse_fn_delete, (void *)&tstruct);
1136 /* Store the linearised queue, max jobs only. */
1137 store_queue_struct(pdb, &tstruct);
1139 SAFE_FREE(tstruct.queue);
1141 DEBUG(10,("print_queue_update_internal: printer %s INFO/total_jobs = %d\n",
1142 sharename, tstruct.total_jobs ));
1144 tdb_store_int32(pdb->tdb, "INFO/total_jobs", tstruct.total_jobs);
1146 get_queue_status(sharename, &old_status);
1147 if (old_status.qcount != qcount)
1148 DEBUG(10,("print_queue_update_internal: queue status change %d jobs -> %d jobs for printer %s\n",
1149 old_status.qcount, qcount, sharename));
1151 /* store the new queue status structure */
1152 slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", sharename);
1154 key.dsize = strlen(keystr);
1156 status.qcount = qcount;
1157 data.dptr = (void *)&status;
1158 data.dsize = sizeof(status);
1159 tdb_store(pdb->tdb, key, data, TDB_REPLACE);
1162 * Update the cache time again. We want to do this call
1163 * as little as possible...
1166 slprintf(keystr, sizeof(keystr)-1, "CACHE/%s", sharename);
1167 tdb_store_int32(pdb->tdb, keystr, (int32)time(NULL));
1171 /****************************************************************************
1172 Update the internal database from the system print queue for a queue.
1173 obtain a lock on the print queue before proceeding (needed when mutiple
1174 smbd processes maytry to update the lpq cache concurrently).
1175 ****************************************************************************/
1177 static void print_queue_update_with_lock(int snum)
1179 fstring sharename, keystr;
1180 pstring lpq_command;
1181 struct tdb_print_db *pdb;
1182 struct printif *current_printif = get_printer_fns( snum );
1184 fstrcpy(sharename, lp_const_servicename(snum));
1186 DEBUG(5,("print_queue_update_with_lock: printer share = %s\n", sharename));
1187 pdb = get_print_db_byname(sharename);
1192 * Check to see if someone else is doing this update.
1193 * This is essentially a mutex on the update.
1196 if (get_updating_pid(sharename) != -1) {
1197 release_print_db(pdb);
1201 /* Lock the queue for the database update */
1203 slprintf(keystr, sizeof(keystr) - 1, "LOCK/%s", sharename);
1204 /* Only wait 10 seconds for this. */
1205 if (tdb_lock_bystring(pdb->tdb, keystr, 10) == -1) {
1206 DEBUG(0,("print_queue_update_with_lock: Failed to lock printer %s database\n", sharename));
1207 release_print_db(pdb);
1212 * Ensure that no one else got in here.
1213 * If the updating pid is still -1 then we are
1217 if (get_updating_pid(sharename) != -1) {
1219 * Someone else is doing the update, exit.
1221 tdb_unlock_bystring(pdb->tdb, keystr);
1222 release_print_db(pdb);
1227 * We're going to do the update ourselves.
1230 /* Tell others we're doing the update. */
1231 set_updating_pid(sharename, True);
1234 * Allow others to enter and notice we're doing
1238 tdb_unlock_bystring(pdb->tdb, keystr);
1240 /* do the main work now */
1241 /* have to substitute any variables here since
1242 print_queue_get_internal() will not */
1244 pstrcpy( lpq_command, lp_lpqcommand(snum) );
1245 pstring_sub( lpq_command, "%p", PRINTERNAME(snum) );
1246 standard_sub_snum( snum, lpq_command, sizeof(lpq_command) );
1248 print_queue_update_internal( sharename, current_printif, lpq_command );
1250 /* Delete our pid from the db. */
1251 set_updating_pid(sharename, False);
1252 release_print_db(pdb);
1255 /****************************************************************************
1256 this is the receive function of the background lpq updater
1257 ****************************************************************************/
1258 static void print_queue_receive(int msg_type, pid_t src, void *buf, size_t len)
1260 struct print_queue_update_context ctx;
1262 if (len != sizeof(struct print_queue_update_context)) {
1263 DEBUG(1, ("Got invalid print queue update message\n"));
1267 memcpy(&ctx, buf, sizeof(struct print_queue_update_context));
1268 print_queue_update_internal(ctx.sharename,
1269 get_printer_fns_from_type(ctx.printing_type),
1273 static pid_t background_lpq_updater_pid = -1;
1275 /****************************************************************************
1276 main thread of the background lpq updater
1277 ****************************************************************************/
1278 void start_background_queue(void)
1280 DEBUG(3,("start_background_queue: Starting background LPQ thread\n"));
1281 background_lpq_updater_pid = sys_fork();
1283 if (background_lpq_updater_pid == -1) {
1284 DEBUG(5,("start_background_queue: background LPQ thread failed to start. %s\n", strerror(errno) ));
1288 if(background_lpq_updater_pid == 0) {
1290 DEBUG(5,("start_background_queue: background LPQ thread started\n"));
1292 claim_connection( NULL, "smbd lpq backend", 0, False,
1293 FLAG_MSG_GENERAL|FLAG_MSG_SMBD|FLAG_MSG_PRINT_GENERAL);
1295 if (!locking_init(0)) {
1299 message_register(MSG_PRINTER_UPDATE, print_queue_receive);
1301 DEBUG(5,("start_background_queue: background LPQ thread waiting for messages\n"));
1305 /* check for some essential signals first */
1308 exit_server("Caught TERM signal");
1311 if (reload_after_sighup) {
1312 change_to_root_user();
1313 DEBUG(1,("Reloading services after SIGHUP\n"));
1314 reload_services(False);
1315 reload_after_sighup = 0;
1318 /* now check for messages */
1320 DEBUG(10,("start_background_queue: background LPQ thread got a message\n"));
1323 /* process any pending print change notify messages */
1325 print_notify_send_messages(0);
1330 /****************************************************************************
1331 update the internal database from the system print queue for a queue
1332 ****************************************************************************/
1333 static void print_queue_update(int snum)
1335 struct print_queue_update_context ctx;
1338 * Make sure that the background queue process exists.
1339 * Otherwise just do the update ourselves
1342 if ( background_lpq_updater_pid != -1 ) {
1343 fstrcpy(ctx.sharename, lp_const_servicename(snum));
1344 ctx.printing_type = lp_printing(snum);
1346 pstrcpy(ctx.lpqcommand, lp_lpqcommand(snum));
1347 pstring_sub( ctx.lpqcommand, "%p", PRINTERNAME(snum) );
1348 standard_sub_snum( snum, ctx.lpqcommand, sizeof(ctx.lpqcommand) );
1350 DEBUG(10,("print_queue_update: Sending message -> printer = %s, "
1351 "type = %d, lpq command = [%s]\n",
1352 ctx.sharename, ctx.printing_type, ctx.lpqcommand ));
1356 message_send_pid(background_lpq_updater_pid,
1357 MSG_PRINTER_UPDATE, &ctx, sizeof(ctx),
1361 print_queue_update_with_lock( snum );
1364 /****************************************************************************
1365 Create/Update an entry in the print tdb that will allow us to send notify
1366 updates only to interested smbd's.
1367 ****************************************************************************/
1369 BOOL print_notify_register_pid(int snum)
1372 struct tdb_print_db *pdb = NULL;
1373 TDB_CONTEXT *tdb = NULL;
1374 const char *printername;
1375 uint32 mypid = (uint32)sys_getpid();
1379 /* if (snum == -1), then the change notify request was
1380 on a print server handle and we need to register on
1385 int num_services = lp_numservices();
1388 for ( idx=0; idx<num_services; idx++ ) {
1389 if (lp_snum_ok(idx) && lp_print_ok(idx) )
1390 print_notify_register_pid(idx);
1395 else /* register for a specific printer */
1397 printername = lp_const_servicename(snum);
1398 pdb = get_print_db_byname(printername);
1404 if (tdb_lock_bystring(tdb, NOTIFY_PID_LIST_KEY, 10) == -1) {
1405 DEBUG(0,("print_notify_register_pid: Failed to lock printer %s\n",
1408 release_print_db(pdb);
1412 data = get_printer_notify_pid_list( tdb, printername, True );
1414 /* Add ourselves and increase the refcount. */
1416 for (i = 0; i < data.dsize; i += 8) {
1417 if (IVAL(data.dptr,i) == mypid) {
1418 uint32 new_refcount = IVAL(data.dptr, i+4) + 1;
1419 SIVAL(data.dptr, i+4, new_refcount);
1424 if (i == data.dsize) {
1425 /* We weren't in the list. Realloc. */
1426 data.dptr = SMB_REALLOC(data.dptr, data.dsize + 8);
1428 DEBUG(0,("print_notify_register_pid: Relloc fail for printer %s\n",
1433 SIVAL(data.dptr,data.dsize - 8,mypid);
1434 SIVAL(data.dptr,data.dsize - 4,1); /* Refcount. */
1437 /* Store back the record. */
1438 if (tdb_store_bystring(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) == -1) {
1439 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1440 list for printer %s\n", printername));
1448 tdb_unlock_bystring(tdb, NOTIFY_PID_LIST_KEY);
1450 release_print_db(pdb);
1451 SAFE_FREE(data.dptr);
1455 /****************************************************************************
1456 Update an entry in the print tdb that will allow us to send notify
1457 updates only to interested smbd's.
1458 ****************************************************************************/
1460 BOOL print_notify_deregister_pid(int snum)
1463 struct tdb_print_db *pdb = NULL;
1464 TDB_CONTEXT *tdb = NULL;
1465 const char *printername;
1466 uint32 mypid = (uint32)sys_getpid();
1470 /* if ( snum == -1 ), we are deregister a print server handle
1471 which means to deregister on all print queues */
1475 int num_services = lp_numservices();
1478 for ( idx=0; idx<num_services; idx++ ) {
1479 if ( lp_snum_ok(idx) && lp_print_ok(idx) )
1480 print_notify_deregister_pid(idx);
1485 else /* deregister a specific printer */
1487 printername = lp_const_servicename(snum);
1488 pdb = get_print_db_byname(printername);
1494 if (tdb_lock_bystring(tdb, NOTIFY_PID_LIST_KEY, 10) == -1) {
1495 DEBUG(0,("print_notify_register_pid: Failed to lock \
1496 printer %s database\n", printername));
1498 release_print_db(pdb);
1502 data = get_printer_notify_pid_list( tdb, printername, True );
1504 /* Reduce refcount. Remove ourselves if zero. */
1506 for (i = 0; i < data.dsize; ) {
1507 if (IVAL(data.dptr,i) == mypid) {
1508 uint32 refcount = IVAL(data.dptr, i+4);
1512 if (refcount == 0) {
1513 if (data.dsize - i > 8)
1514 memmove( &data.dptr[i], &data.dptr[i+8], data.dsize - i - 8);
1518 SIVAL(data.dptr, i+4, refcount);
1524 if (data.dsize == 0)
1525 SAFE_FREE(data.dptr);
1527 /* Store back the record. */
1528 if (tdb_store_bystring(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) == -1) {
1529 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1530 list for printer %s\n", printername));
1538 tdb_unlock_bystring(tdb, NOTIFY_PID_LIST_KEY);
1540 release_print_db(pdb);
1541 SAFE_FREE(data.dptr);
1545 /****************************************************************************
1546 Check if a jobid is valid. It is valid if it exists in the database.
1547 ****************************************************************************/
1549 BOOL print_job_exists(const char* sharename, uint32 jobid)
1551 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1556 ret = tdb_exists(pdb->tdb, print_key(jobid));
1557 release_print_db(pdb);
1561 /****************************************************************************
1562 Give the fd used for a jobid.
1563 ****************************************************************************/
1565 int print_job_fd(const char* sharename, uint32 jobid)
1567 struct printjob *pjob = print_job_find(sharename, jobid);
1570 /* don't allow another process to get this info - it is meaningless */
1571 if (pjob->pid != sys_getpid())
1576 /****************************************************************************
1577 Give the filename used for a jobid.
1578 Only valid for the process doing the spooling and when the job
1579 has not been spooled.
1580 ****************************************************************************/
1582 char *print_job_fname(const char* sharename, uint32 jobid)
1584 struct printjob *pjob = print_job_find(sharename, jobid);
1585 if (!pjob || pjob->spooled || pjob->pid != sys_getpid())
1587 return pjob->filename;
1591 /****************************************************************************
1592 Give the filename used for a jobid.
1593 Only valid for the process doing the spooling and when the job
1594 has not been spooled.
1595 ****************************************************************************/
1597 NT_DEVICEMODE *print_job_devmode(const char* sharename, uint32 jobid)
1599 struct printjob *pjob = print_job_find(sharename, jobid);
1604 return pjob->nt_devmode;
1607 /****************************************************************************
1608 Set the place in the queue for a job.
1609 ****************************************************************************/
1611 BOOL print_job_set_place(int snum, uint32 jobid, int place)
1613 DEBUG(2,("print_job_set_place not implemented yet\n"));
1617 /****************************************************************************
1618 Set the name of a job. Only possible for owner.
1619 ****************************************************************************/
1621 BOOL print_job_set_name(int snum, uint32 jobid, char *name)
1623 const char* sharename = lp_const_servicename(snum);
1624 struct printjob *pjob;
1626 pjob = print_job_find(sharename, jobid);
1627 if (!pjob || pjob->pid != sys_getpid())
1630 fstrcpy(pjob->jobname, name);
1631 return pjob_store(sharename, jobid, pjob);
1634 /***************************************************************************
1635 Remove a jobid from the 'jobs changed' list.
1636 ***************************************************************************/
1638 static BOOL remove_from_jobs_changed(const char* sharename, uint32 jobid)
1640 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1642 size_t job_count, i;
1644 BOOL gotlock = False;
1646 key.dptr = "INFO/jobs_changed";
1647 key.dsize = strlen(key.dptr);
1650 if (tdb_chainlock_with_timeout(pdb->tdb, key, 5) == -1)
1655 data = tdb_fetch(pdb->tdb, key);
1657 if (data.dptr == NULL || data.dsize == 0 || (data.dsize % 4 != 0))
1660 job_count = data.dsize / 4;
1661 for (i = 0; i < job_count; i++) {
1664 ch_jobid = IVAL(data.dptr, i*4);
1665 if (ch_jobid == jobid) {
1666 if (i < job_count -1 )
1667 memmove(data.dptr + (i*4), data.dptr + (i*4) + 4, (job_count - i - 1)*4 );
1669 if (tdb_store(pdb->tdb, key, data, TDB_REPLACE) == -1)
1679 tdb_chainunlock(pdb->tdb, key);
1680 SAFE_FREE(data.dptr);
1681 release_print_db(pdb);
1683 DEBUG(10,("remove_from_jobs_changed: removed jobid %u\n", (unsigned int)jobid ));
1685 DEBUG(10,("remove_from_jobs_changed: Failed to remove jobid %u\n", (unsigned int)jobid ));
1689 /****************************************************************************
1690 Delete a print job - don't update queue.
1691 ****************************************************************************/
1693 static BOOL print_job_delete1(int snum, uint32 jobid)
1695 const char* sharename = lp_const_servicename(snum);
1696 struct printjob *pjob = print_job_find(sharename, jobid);
1698 struct printif *current_printif = get_printer_fns( snum );
1700 pjob = print_job_find(sharename, jobid);
1706 * If already deleting just return.
1709 if (pjob->status == LPQ_DELETING)
1712 /* Hrm - we need to be able to cope with deleting a job before it
1713 has reached the spooler. */
1715 if (pjob->sysjob == -1) {
1716 DEBUG(5, ("attempt to delete job %u not seen by lpr\n", (unsigned int)jobid));
1719 /* Set the tdb entry to be deleting. */
1721 pjob->status = LPQ_DELETING;
1722 pjob_store(sharename, jobid, pjob);
1724 if (pjob->spooled && pjob->sysjob != -1)
1725 result = (*(current_printif->job_delete))(snum, pjob);
1727 /* Delete the tdb entry if the delete succeeded or the job hasn't
1731 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1736 pjob_delete(sharename, jobid);
1737 /* Ensure we keep a rough count of the number of total jobs... */
1738 tdb_change_int32_atomic(pdb->tdb, "INFO/total_jobs", &njobs, -1);
1739 release_print_db(pdb);
1742 return (result == 0);
1745 /****************************************************************************
1746 Return true if the current user owns the print job.
1747 ****************************************************************************/
1749 static BOOL is_owner(struct current_user *user, int snum, uint32 jobid)
1751 struct printjob *pjob = print_job_find(lp_const_servicename(snum), jobid);
1757 if ((vuser = get_valid_user_struct(user->vuid)) != NULL) {
1758 return strequal(pjob->user, vuser->user.smb_name);
1760 return strequal(pjob->user, uidtoname(user->uid));
1764 /****************************************************************************
1766 ****************************************************************************/
1768 BOOL print_job_delete(struct current_user *user, int snum, uint32 jobid, WERROR *errcode)
1770 const char* sharename = lp_const_servicename( snum );
1771 BOOL owner, deleted;
1776 owner = is_owner(user, snum, jobid);
1778 /* Check access against security descriptor or whether the user
1782 !print_access_check(user, snum, JOB_ACCESS_ADMINISTER)) {
1783 DEBUG(3, ("delete denied by security descriptor\n"));
1784 *errcode = WERR_ACCESS_DENIED;
1786 /* BEGIN_ADMIN_LOG */
1787 sys_adminlog( LOG_ERR,
1788 "Permission denied-- user not allowed to delete, \
1789 pause, or resume print job. User name: %s. Printer name: %s.",
1790 uidtoname(user->uid), PRINTERNAME(snum) );
1797 * get the spooled filename of the print job
1798 * if this works, then the file has not been spooled
1799 * to the underlying print system. Just delete the
1800 * spool file & return.
1803 if ( (fname = print_job_fname( sharename, jobid )) != NULL )
1805 /* remove the spool file */
1806 DEBUG(10,("print_job_delete: Removing spool file [%s]\n", fname ));
1807 if ( unlink( fname ) == -1 ) {
1808 *errcode = map_werror_from_unix(errno);
1813 if (!print_job_delete1(snum, jobid)) {
1814 *errcode = WERR_ACCESS_DENIED;
1818 /* force update the database and say the delete failed if the
1821 print_queue_update(snum);
1823 deleted = !print_job_exists(sharename, jobid);
1825 *errcode = WERR_ACCESS_DENIED;
1830 /****************************************************************************
1832 ****************************************************************************/
1834 BOOL print_job_pause(struct current_user *user, int snum, uint32 jobid, WERROR *errcode)
1836 const char* sharename = lp_const_servicename(snum);
1837 struct printjob *pjob;
1839 struct printif *current_printif = get_printer_fns( snum );
1841 pjob = print_job_find(sharename, jobid);
1846 if (!pjob->spooled || pjob->sysjob == -1)
1849 if (!is_owner(user, snum, jobid) &&
1850 !print_access_check(user, snum, JOB_ACCESS_ADMINISTER)) {
1851 DEBUG(3, ("pause denied by security descriptor\n"));
1853 /* BEGIN_ADMIN_LOG */
1854 sys_adminlog( LOG_ERR,
1855 "Permission denied-- user not allowed to delete, \
1856 pause, or resume print job. User name: %s. Printer name: %s.",
1857 uidtoname(user->uid), PRINTERNAME(snum) );
1860 *errcode = WERR_ACCESS_DENIED;
1864 /* need to pause the spooled entry */
1865 ret = (*(current_printif->job_pause))(snum, pjob);
1868 *errcode = WERR_INVALID_PARAM;
1872 /* force update the database */
1873 print_cache_flush(snum);
1875 /* Send a printer notify message */
1877 notify_job_status(sharename, jobid, JOB_STATUS_PAUSED);
1879 /* how do we tell if this succeeded? */
1884 /****************************************************************************
1886 ****************************************************************************/
1888 BOOL print_job_resume(struct current_user *user, int snum, uint32 jobid, WERROR *errcode)
1890 const char *sharename = lp_const_servicename(snum);
1891 struct printjob *pjob;
1893 struct printif *current_printif = get_printer_fns( snum );
1895 pjob = print_job_find(sharename, jobid);
1900 if (!pjob->spooled || pjob->sysjob == -1)
1903 if (!is_owner(user, snum, jobid) &&
1904 !print_access_check(user, snum, JOB_ACCESS_ADMINISTER)) {
1905 DEBUG(3, ("resume denied by security descriptor\n"));
1906 *errcode = WERR_ACCESS_DENIED;
1908 /* BEGIN_ADMIN_LOG */
1909 sys_adminlog( LOG_ERR,
1910 "Permission denied-- user not allowed to delete, \
1911 pause, or resume print job. User name: %s. Printer name: %s.",
1912 uidtoname(user->uid), PRINTERNAME(snum) );
1917 ret = (*(current_printif->job_resume))(snum, pjob);
1920 *errcode = WERR_INVALID_PARAM;
1924 /* force update the database */
1925 print_cache_flush(snum);
1927 /* Send a printer notify message */
1929 notify_job_status(sharename, jobid, JOB_STATUS_QUEUED);
1934 /****************************************************************************
1935 Write to a print file.
1936 ****************************************************************************/
1938 int print_job_write(int snum, uint32 jobid, const char *buf, int size)
1940 const char* sharename = lp_const_servicename(snum);
1942 struct printjob *pjob;
1944 pjob = print_job_find(sharename, jobid);
1948 /* don't allow another process to get this info - it is meaningless */
1949 if (pjob->pid != sys_getpid())
1952 return_code = write(pjob->fd, buf, size);
1953 if (return_code>0) {
1955 pjob_store(sharename, jobid, pjob);
1960 /****************************************************************************
1961 Get the queue status - do not update if db is out of date.
1962 ****************************************************************************/
1964 static int get_queue_status(const char* sharename, print_status_struct *status)
1968 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1975 ZERO_STRUCTP(status);
1976 slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", sharename);
1978 key.dsize = strlen(keystr);
1979 data = tdb_fetch(pdb->tdb, key);
1981 if (data.dsize == sizeof(print_status_struct))
1982 /* this memcpy is ok since the status struct was
1983 not packed before storing it in the tdb */
1984 memcpy(status, data.dptr, sizeof(print_status_struct));
1985 SAFE_FREE(data.dptr);
1988 len = tdb_fetch_int32(pdb->tdb, "INFO/total_jobs");
1989 release_print_db(pdb);
1990 return (len == -1 ? 0 : len);
1993 /****************************************************************************
1994 Determine the number of jobs in a queue.
1995 ****************************************************************************/
1997 int print_queue_length(int snum, print_status_struct *pstatus)
1999 const char* sharename = lp_const_servicename( snum );
2000 print_status_struct status;
2003 /* make sure the database is up to date */
2004 if (print_cache_expired(lp_const_servicename(snum)))
2005 print_queue_update(snum);
2007 /* also fetch the queue status */
2008 memset(&status, 0, sizeof(status));
2009 len = get_queue_status(sharename, &status);
2017 /***************************************************************************
2018 Allocate a jobid. Hold the lock for as short a time as possible.
2019 ***************************************************************************/
2021 static BOOL allocate_print_jobid(struct tdb_print_db *pdb, int snum, const char *sharename, uint32 *pjobid)
2026 *pjobid = (uint32)-1;
2028 for (i = 0; i < 3; i++) {
2029 /* Lock the database - only wait 20 seconds. */
2030 if (tdb_lock_bystring(pdb->tdb, "INFO/nextjob", 20) == -1) {
2031 DEBUG(0,("allocate_print_jobid: failed to lock printing database %s\n", sharename));
2035 if (!tdb_fetch_uint32(pdb->tdb, "INFO/nextjob", &jobid)) {
2036 if (tdb_error(pdb->tdb) != TDB_ERR_NOEXIST) {
2037 DEBUG(0, ("allocate_print_jobid: failed to fetch INFO/nextjob for print queue %s\n",
2044 jobid = NEXT_JOBID(jobid);
2046 if (tdb_store_int32(pdb->tdb, "INFO/nextjob", jobid)==-1) {
2047 DEBUG(3, ("allocate_print_jobid: failed to store INFO/nextjob.\n"));
2048 tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
2052 /* We've finished with the INFO/nextjob lock. */
2053 tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
2055 if (!print_job_exists(sharename, jobid))
2060 DEBUG(0, ("allocate_print_jobid: failed to allocate a print job for queue %s\n",
2062 /* Probably full... */
2067 /* Store a dummy placeholder. */
2072 if (tdb_store(pdb->tdb, print_key(jobid), dum, TDB_INSERT) == -1) {
2073 DEBUG(3, ("allocate_print_jobid: jobid (%d) failed to store placeholder.\n",
2083 /***************************************************************************
2084 Append a jobid to the 'jobs changed' list.
2085 ***************************************************************************/
2087 static BOOL add_to_jobs_changed(struct tdb_print_db *pdb, uint32 jobid)
2092 key.dptr = "INFO/jobs_changed";
2093 key.dsize = strlen(key.dptr);
2094 SIVAL(&store_jobid, 0, jobid);
2095 data.dptr = (char *)&store_jobid;
2098 DEBUG(10,("add_to_jobs_changed: Added jobid %u\n", (unsigned int)jobid ));
2100 return (tdb_append(pdb->tdb, key, data) == 0);
2103 /***************************************************************************
2104 Start spooling a job - return the jobid.
2105 ***************************************************************************/
2107 uint32 print_job_start(struct current_user *user, int snum, char *jobname, NT_DEVICEMODE *nt_devmode )
2111 struct printjob pjob;
2113 const char *sharename = lp_const_servicename(snum);
2114 struct tdb_print_db *pdb = get_print_db_byname(sharename);
2122 if (!print_access_check(user, snum, PRINTER_ACCESS_USE)) {
2123 DEBUG(3, ("print_job_start: job start denied by security descriptor\n"));
2124 release_print_db(pdb);
2128 if (!print_time_access_check(snum)) {
2129 DEBUG(3, ("print_job_start: job start denied by time check\n"));
2130 release_print_db(pdb);
2134 path = lp_pathname(snum);
2136 /* see if we have sufficient disk space */
2137 if (lp_minprintspace(snum)) {
2138 SMB_BIG_UINT dspace, dsize;
2139 if (sys_fsusage(path, &dspace, &dsize) == 0 &&
2140 dspace < 2*(SMB_BIG_UINT)lp_minprintspace(snum)) {
2141 DEBUG(3, ("print_job_start: disk space check failed.\n"));
2142 release_print_db(pdb);
2148 /* for autoloaded printers, check that the printcap entry still exists */
2149 if (lp_autoloaded(snum) && !pcap_printername_ok(lp_const_servicename(snum), NULL)) {
2150 DEBUG(3, ("print_job_start: printer name %s check failed.\n", lp_const_servicename(snum) ));
2151 release_print_db(pdb);
2156 /* Insure the maximum queue size is not violated */
2157 if ((njobs = print_queue_length(snum,NULL)) > lp_maxprintjobs(snum)) {
2158 DEBUG(3, ("print_job_start: Queue %s number of jobs (%d) larger than max printjobs per queue (%d).\n",
2159 sharename, njobs, lp_maxprintjobs(snum) ));
2160 release_print_db(pdb);
2165 DEBUG(10,("print_job_start: Queue %s number of jobs (%d), max printjobs = %d\n",
2166 sharename, njobs, lp_maxprintjobs(snum) ));
2168 if (!allocate_print_jobid(pdb, snum, sharename, &jobid))
2171 /* create the database entry */
2175 pjob.pid = sys_getpid();
2178 pjob.starttime = time(NULL);
2179 pjob.status = LPQ_SPOOLING;
2181 pjob.spooled = False;
2183 pjob.nt_devmode = nt_devmode;
2185 fstrcpy(pjob.jobname, jobname);
2187 if ((vuser = get_valid_user_struct(user->vuid)) != NULL) {
2188 fstrcpy(pjob.user, vuser->user.smb_name);
2190 fstrcpy(pjob.user, uidtoname(user->uid));
2193 fstrcpy(pjob.queuename, lp_const_servicename(snum));
2195 /* we have a job entry - now create the spool file */
2196 slprintf(pjob.filename, sizeof(pjob.filename)-1, "%s/%s%.8u.XXXXXX",
2197 path, PRINT_SPOOL_PREFIX, (unsigned int)jobid);
2198 pjob.fd = smb_mkstemp(pjob.filename);
2200 if (pjob.fd == -1) {
2201 if (errno == EACCES) {
2202 /* Common setup error, force a report. */
2203 DEBUG(0, ("print_job_start: insufficient permissions \
2204 to open spool file %s.\n", pjob.filename));
2206 /* Normal case, report at level 3 and above. */
2207 DEBUG(3, ("print_job_start: can't open spool file %s,\n", pjob.filename));
2208 DEBUGADD(3, ("errno = %d (%s).\n", errno, strerror(errno)));
2213 pjob_store(sharename, jobid, &pjob);
2215 /* Update the 'jobs changed' entry used by print_queue_status. */
2216 add_to_jobs_changed(pdb, jobid);
2218 /* Ensure we keep a rough count of the number of total jobs... */
2219 tdb_change_int32_atomic(pdb->tdb, "INFO/total_jobs", &njobs, 1);
2221 release_print_db(pdb);
2227 pjob_delete(sharename, jobid);
2229 release_print_db(pdb);
2231 DEBUG(3, ("print_job_start: returning fail. Error = %s\n", strerror(errno) ));
2235 /****************************************************************************
2236 Update the number of pages spooled to jobid
2237 ****************************************************************************/
2239 void print_job_endpage(int snum, uint32 jobid)
2241 const char* sharename = lp_const_servicename(snum);
2242 struct printjob *pjob;
2244 pjob = print_job_find(sharename, jobid);
2247 /* don't allow another process to get this info - it is meaningless */
2248 if (pjob->pid != sys_getpid())
2252 pjob_store(sharename, jobid, pjob);
2255 /****************************************************************************
2256 Print a file - called on closing the file. This spools the job.
2257 If normal close is false then we're tearing down the jobs - treat as an
2259 ****************************************************************************/
2261 BOOL print_job_end(int snum, uint32 jobid, BOOL normal_close)
2263 const char* sharename = lp_const_servicename(snum);
2264 struct printjob *pjob;
2266 SMB_STRUCT_STAT sbuf;
2267 struct printif *current_printif = get_printer_fns( snum );
2269 pjob = print_job_find(sharename, jobid);
2274 if (pjob->spooled || pjob->pid != sys_getpid())
2277 if (normal_close && (sys_fstat(pjob->fd, &sbuf) == 0)) {
2278 pjob->size = sbuf.st_size;
2284 * Not a normal close or we couldn't stat the job file,
2285 * so something has gone wrong. Cleanup.
2289 DEBUG(3,("print_job_end: failed to stat file for jobid %d\n", jobid ));
2293 /* Technically, this is not quite right. If the printer has a separator
2294 * page turned on, the NT spooler prints the separator page even if the
2295 * print job is 0 bytes. 010215 JRR */
2296 if (pjob->size == 0 || pjob->status == LPQ_DELETING) {
2297 /* don't bother spooling empty files or something being deleted. */
2298 DEBUG(5,("print_job_end: canceling spool of %s (%s)\n",
2299 pjob->filename, pjob->size ? "deleted" : "zero length" ));
2300 unlink(pjob->filename);
2301 pjob_delete(sharename, jobid);
2305 pjob->smbjob = jobid;
2307 ret = (*(current_printif->job_submit))(snum, pjob);
2312 /* The print job has been sucessfully handed over to the back-end */
2314 pjob->spooled = True;
2315 pjob->status = LPQ_QUEUED;
2316 pjob_store(sharename, jobid, pjob);
2318 /* make sure the database is up to date */
2319 if (print_cache_expired(lp_const_servicename(snum)))
2320 print_queue_update(snum);
2326 /* The print job was not succesfully started. Cleanup */
2327 /* Still need to add proper error return propagation! 010122:JRR */
2328 unlink(pjob->filename);
2329 pjob_delete(sharename, jobid);
2333 /****************************************************************************
2334 Get a snapshot of jobs in the system without traversing.
2335 ****************************************************************************/
2337 static BOOL get_stored_queue_info(struct tdb_print_db *pdb, int snum, int *pcount, print_queue_struct **ppqueue)
2339 TDB_DATA data, key, cgdata;
2340 print_queue_struct *queue = NULL;
2342 uint32 extra_count = 0;
2343 int total_count = 0;
2346 int max_reported_jobs = lp_max_reported_jobs(snum);
2348 const char* sharename = lp_servicename(snum);
2350 /* make sure the database is up to date */
2351 if (print_cache_expired(lp_const_servicename(snum)))
2352 print_queue_update(snum);
2358 ZERO_STRUCT(cgdata);
2359 key.dptr = "INFO/linear_queue_array";
2360 key.dsize = strlen(key.dptr);
2362 /* Get the stored queue data. */
2363 data = tdb_fetch(pdb->tdb, key);
2365 if (data.dptr && data.dsize >= sizeof(qcount))
2366 len += tdb_unpack(data.dptr + len, data.dsize - len, "d", &qcount);
2368 /* Get the changed jobs list. */
2369 key.dptr = "INFO/jobs_changed";
2370 key.dsize = strlen(key.dptr);
2372 cgdata = tdb_fetch(pdb->tdb, key);
2373 if (cgdata.dptr != NULL && (cgdata.dsize % 4 == 0))
2374 extra_count = cgdata.dsize/4;
2376 DEBUG(5,("get_stored_queue_info: qcount = %u, extra_count = %u\n", (unsigned int)qcount, (unsigned int)extra_count));
2378 /* Allocate the queue size. */
2379 if (qcount == 0 && extra_count == 0)
2382 if ((queue = SMB_MALLOC_ARRAY(print_queue_struct, qcount + extra_count)) == NULL)
2385 /* Retrieve the linearised queue data. */
2387 for( i = 0; i < qcount; i++) {
2388 uint32 qjob, qsize, qpage_count, qstatus, qpriority, qtime;
2389 len += tdb_unpack(data.dptr + len, data.dsize - len, "ddddddff",
2398 queue[i].job = qjob;
2399 queue[i].size = qsize;
2400 queue[i].page_count = qpage_count;
2401 queue[i].status = qstatus;
2402 queue[i].priority = qpriority;
2403 queue[i].time = qtime;
2406 total_count = qcount;
2408 /* Add in the changed jobids. */
2409 for( i = 0; i < extra_count; i++) {
2411 struct printjob *pjob;
2413 jobid = IVAL(cgdata.dptr, i*4);
2414 DEBUG(5,("get_stored_queue_info: changed job = %u\n", (unsigned int)jobid));
2415 pjob = print_job_find(lp_const_servicename(snum), jobid);
2417 DEBUG(5,("get_stored_queue_info: failed to find changed job = %u\n", (unsigned int)jobid));
2418 remove_from_jobs_changed(sharename, jobid);
2422 queue[total_count].job = jobid;
2423 queue[total_count].size = pjob->size;
2424 queue[total_count].page_count = pjob->page_count;
2425 queue[total_count].status = pjob->status;
2426 queue[total_count].priority = 1;
2427 queue[total_count].time = pjob->starttime;
2428 fstrcpy(queue[total_count].fs_user, pjob->user);
2429 fstrcpy(queue[total_count].fs_file, pjob->jobname);
2433 /* Sort the queue by submission time otherwise they are displayed
2436 qsort(queue, total_count, sizeof(print_queue_struct), QSORT_CAST(printjob_comp));
2438 DEBUG(5,("get_stored_queue_info: total_count = %u\n", (unsigned int)total_count));
2440 if (max_reported_jobs && total_count > max_reported_jobs)
2441 total_count = max_reported_jobs;
2444 *pcount = total_count;
2450 SAFE_FREE(data.dptr);
2451 SAFE_FREE(cgdata.dptr);
2455 /****************************************************************************
2456 Get a printer queue listing.
2457 set queue = NULL and status = NULL if you just want to update the cache
2458 ****************************************************************************/
2460 int print_queue_status(int snum,
2461 print_queue_struct **ppqueue,
2462 print_status_struct *status)
2466 const char *sharename;
2467 struct tdb_print_db *pdb;
2470 /* make sure the database is up to date */
2472 if (print_cache_expired(lp_const_servicename(snum)))
2473 print_queue_update(snum);
2475 /* return if we are done */
2476 if ( !ppqueue || !status )
2480 sharename = lp_const_servicename(snum);
2481 pdb = get_print_db_byname(sharename);
2487 * Fetch the queue status. We must do this first, as there may
2488 * be no jobs in the queue.
2491 ZERO_STRUCTP(status);
2492 slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", sharename);
2494 key.dsize = strlen(keystr);
2495 data = tdb_fetch(pdb->tdb, key);
2497 if (data.dsize == sizeof(*status)) {
2498 /* this memcpy is ok since the status struct was
2499 not packed before storing it in the tdb */
2500 memcpy(status, data.dptr, sizeof(*status));
2502 SAFE_FREE(data.dptr);
2506 * Now, fetch the print queue information. We first count the number
2507 * of entries, and then only retrieve the queue if necessary.
2510 if (!get_stored_queue_info(pdb, snum, &count, ppqueue)) {
2511 release_print_db(pdb);
2515 release_print_db(pdb);
2519 /****************************************************************************
2521 ****************************************************************************/
2523 BOOL print_queue_pause(struct current_user *user, int snum, WERROR *errcode)
2526 struct printif *current_printif = get_printer_fns( snum );
2528 if (!print_access_check(user, snum, PRINTER_ACCESS_ADMINISTER)) {
2529 *errcode = WERR_ACCESS_DENIED;
2533 ret = (*(current_printif->queue_pause))(snum);
2536 *errcode = WERR_INVALID_PARAM;
2540 /* force update the database */
2541 print_cache_flush(snum);
2543 /* Send a printer notify message */
2545 notify_printer_status(snum, PRINTER_STATUS_PAUSED);
2550 /****************************************************************************
2552 ****************************************************************************/
2554 BOOL print_queue_resume(struct current_user *user, int snum, WERROR *errcode)
2557 struct printif *current_printif = get_printer_fns( snum );
2559 if (!print_access_check(user, snum, PRINTER_ACCESS_ADMINISTER)) {
2560 *errcode = WERR_ACCESS_DENIED;
2564 ret = (*(current_printif->queue_resume))(snum);
2567 *errcode = WERR_INVALID_PARAM;
2571 /* make sure the database is up to date */
2572 if (print_cache_expired(lp_const_servicename(snum)))
2573 print_queue_update(snum);
2575 /* Send a printer notify message */
2577 notify_printer_status(snum, PRINTER_STATUS_OK);
2582 /****************************************************************************
2583 Purge a queue - implemented by deleting all jobs that we can delete.
2584 ****************************************************************************/
2586 BOOL print_queue_purge(struct current_user *user, int snum, WERROR *errcode)
2588 print_queue_struct *queue;
2589 print_status_struct status;
2593 /* Force and update so the count is accurate (i.e. not a cached count) */
2594 print_queue_update(snum);
2596 can_job_admin = print_access_check(user, snum, JOB_ACCESS_ADMINISTER);
2597 njobs = print_queue_status(snum, &queue, &status);
2599 for (i=0;i<njobs;i++) {
2600 BOOL owner = is_owner(user, snum, queue[i].job);
2602 if (owner || can_job_admin) {
2603 print_job_delete1(snum, queue[i].job);