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.
25 /* Current printer interface */
26 static struct printif *current_printif = &generic_printif;
27 static BOOL remove_from_jobs_changed(int snum, uint32 jobid);
30 the printing backend revolves around a tdb database that stores the
31 SMB view of the print queue
33 The key for this database is a jobid - a internally generated number that
34 uniquely identifies a print job
36 reading the print queue involves two steps:
37 - possibly running lpq and updating the internal database from that
38 - reading entries from the database
40 jobids are assigned when a job starts spooling.
43 /***************************************************************************
44 Nightmare. LANMAN jobid's are 16 bit numbers..... We must map them to 32
45 bit RPC jobids.... JRA.
46 ***************************************************************************/
48 static TDB_CONTEXT *rap_tdb;
49 static uint16 next_rap_jobid;
51 uint16 pjobid_to_rap(int snum, uint32 jobid)
57 DEBUG(10,("pjobid_to_rap: called.\n"));
60 /* Create the in-memory tdb. */
61 rap_tdb = tdb_open_log(NULL, 0, TDB_INTERNAL, (O_RDWR|O_CREAT), 0644);
66 SIVAL(&jinfo,0,(int32)snum);
67 SIVAL(&jinfo,4,jobid);
69 key.dptr = (char *)&jinfo;
70 key.dsize = sizeof(jinfo);
71 data = tdb_fetch(rap_tdb, key);
72 if (data.dptr && data.dsize == sizeof(uint16)) {
73 memcpy(&rap_jobid, data.dptr, sizeof(uint16));
75 DEBUG(10,("pjobid_to_rap: jobid %u maps to RAP jobid %u\n",
77 (unsigned int)rap_jobid));
81 /* Not found - create and store mapping. */
82 rap_jobid = ++next_rap_jobid;
84 rap_jobid = ++next_rap_jobid;
85 data.dptr = (char *)&rap_jobid;
86 data.dsize = sizeof(rap_jobid);
87 tdb_store(rap_tdb, key, data, TDB_REPLACE);
88 tdb_store(rap_tdb, data, key, TDB_REPLACE);
90 DEBUG(10,("pjobid_to_rap: created jobid %u maps to RAP jobid %u\n",
92 (unsigned int)rap_jobid));
96 BOOL rap_to_pjobid(uint16 rap_jobid, int *psnum, uint32 *pjobid)
100 DEBUG(10,("rap_to_pjobid called.\n"));
105 key.dptr = (char *)&rap_jobid;
106 key.dsize = sizeof(rap_jobid);
107 data = tdb_fetch(rap_tdb, key);
108 if (data.dptr && data.dsize == 8) {
109 *psnum = IVAL(data.dptr,0);
110 *pjobid = IVAL(data.dptr,4);
111 DEBUG(10,("rap_to_pjobid: jobid %u maps to RAP jobid %u\n",
112 (unsigned int)*pjobid,
113 (unsigned int)rap_jobid));
114 SAFE_FREE(data.dptr);
118 DEBUG(10,("rap_to_pjobid: Failed to lookup RAP jobid %u\n",
119 (unsigned int)rap_jobid));
120 SAFE_FREE(data.dptr);
124 static void rap_jobid_delete(int snum, uint32 jobid)
130 DEBUG(10,("rap_jobid_delete: called.\n"));
135 SIVAL(&jinfo,0,(int32)snum);
136 SIVAL(&jinfo,4,jobid);
138 key.dptr = (char *)&jinfo;
139 key.dsize = sizeof(jinfo);
140 data = tdb_fetch(rap_tdb, key);
141 if (!data.dptr || (data.dsize != sizeof(uint16))) {
142 DEBUG(10,("rap_jobid_delete: cannot find jobid %u\n",
143 (unsigned int)jobid ));
144 SAFE_FREE(data.dptr);
148 DEBUG(10,("rap_jobid_delete: deleting jobid %u\n",
149 (unsigned int)jobid ));
151 memcpy(&rap_jobid, data.dptr, sizeof(uint16));
152 SAFE_FREE(data.dptr);
153 data.dptr = (char *)&rap_jobid;
154 data.dsize = sizeof(rap_jobid);
155 tdb_delete(rap_tdb, key);
156 tdb_delete(rap_tdb, data);
159 static pid_t local_pid;
161 static int get_queue_status(int, print_status_struct *);
163 /****************************************************************************
164 Initialise the printing backend. Called once at startup before the fork().
165 ****************************************************************************/
167 BOOL print_backend_init(void)
169 const char *sversion = "INFO/version";
170 pstring printing_path;
171 int services = lp_numservices();
174 if (local_pid == sys_getpid())
177 unlink(lock_path("printing.tdb"));
178 pstrcpy(printing_path,lock_path("printing"));
179 mkdir(printing_path,0755);
181 local_pid = sys_getpid();
183 /* handle a Samba upgrade */
185 for (snum = 0; snum < services; snum++) {
186 struct tdb_print_db *pdb;
187 if (!lp_print_ok(snum))
190 pdb = get_print_db_byname(lp_const_servicename(snum));
193 if (tdb_lock_bystring(pdb->tdb, sversion, 0) == -1) {
194 DEBUG(0,("print_backend_init: Failed to open printer %s database\n", lp_const_servicename(snum) ));
195 release_print_db(pdb);
198 if (tdb_fetch_int32(pdb->tdb, sversion) != PRINT_DATABASE_VERSION) {
199 tdb_traverse(pdb->tdb, tdb_traverse_delete_fn, NULL);
200 tdb_store_int32(pdb->tdb, sversion, PRINT_DATABASE_VERSION);
202 tdb_unlock_bystring(pdb->tdb, sversion);
203 release_print_db(pdb);
206 close_all_print_db(); /* Don't leave any open. */
208 /* select the appropriate printing interface... */
210 if (strcmp(lp_printcapname(), "cups") == 0)
211 current_printif = &cups_printif;
212 #endif /* HAVE_CUPS */
214 /* do NT print initialization... */
215 return nt_printing_init();
218 /****************************************************************************
219 Shut down printing backend. Called once at shutdown to close the tdb.
220 ****************************************************************************/
222 void printing_end(void)
224 close_all_print_db(); /* Don't leave any open. */
227 /****************************************************************************
228 Useful function to generate a tdb key.
229 ****************************************************************************/
231 static TDB_DATA print_key(uint32 jobid)
237 ret.dptr = (void *)&j;
238 ret.dsize = sizeof(j);
242 /***********************************************************************
243 unpack a pjob from a tdb buffer
244 ***********************************************************************/
246 int unpack_pjob( char* buf, int buflen, struct printjob *pjob )
250 uint32 pjpid, pjsysjob, pjfd, pjstarttime, pjstatus;
251 uint32 pjsize, pjpage_count, pjspooled, pjsmbjob;
256 len += tdb_unpack(buf+len, buflen-len, "dddddddddffff",
274 if ( (used = unpack_devicemode(&pjob->nt_devmode, buf+len, buflen-len)) == -1 )
280 pjob->sysjob = pjsysjob;
282 pjob->starttime = pjstarttime;
283 pjob->status = pjstatus;
285 pjob->page_count = pjpage_count;
286 pjob->spooled = pjspooled;
287 pjob->smbjob = pjsmbjob;
293 /****************************************************************************
294 Useful function to find a print job in the database.
295 ****************************************************************************/
297 static struct printjob *print_job_find(int snum, uint32 jobid)
299 static struct printjob pjob;
301 struct tdb_print_db *pdb = get_print_db_byname(lp_const_servicename(snum));
307 ret = tdb_fetch(pdb->tdb, print_key(jobid));
308 release_print_db(pdb);
313 if ( pjob.nt_devmode )
314 free_nt_devicemode( &pjob.nt_devmode );
318 if ( unpack_pjob( ret.dptr, ret.dsize, &pjob ) == -1 ) {
327 /* Convert a unix jobid to a smb jobid */
329 static uint32 sysjob_to_jobid_value;
331 static int unixjob_traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA key,
332 TDB_DATA data, void *state)
334 struct printjob *pjob;
335 int *sysjob = (int *)state;
337 if (!data.dptr || data.dsize == 0)
340 pjob = (struct printjob *)data.dptr;
341 if (key.dsize != sizeof(uint32))
344 if (*sysjob == pjob->sysjob) {
345 uint32 *jobid = (uint32 *)key.dptr;
347 sysjob_to_jobid_value = *jobid;
354 /****************************************************************************
355 This is a *horribly expensive call as we have to iterate through all the
356 current printer tdb's. Don't do this often ! JRA.
357 ****************************************************************************/
359 uint32 sysjob_to_jobid(int unix_jobid)
361 int services = lp_numservices();
364 sysjob_to_jobid_value = (uint32)-1;
366 for (snum = 0; snum < services; snum++) {
367 struct tdb_print_db *pdb;
368 if (!lp_print_ok(snum))
370 pdb = get_print_db_byname(lp_const_servicename(snum));
372 tdb_traverse(pdb->tdb, unixjob_traverse_fn, &unix_jobid);
373 release_print_db(pdb);
374 if (sysjob_to_jobid_value != (uint32)-1)
375 return sysjob_to_jobid_value;
380 /****************************************************************************
381 Send notifications based on what has changed after a pjob_store.
382 ****************************************************************************/
386 uint32 spoolss_status;
387 } lpq_to_spoolss_status_map[] = {
388 { LPQ_QUEUED, JOB_STATUS_QUEUED },
389 { LPQ_PAUSED, JOB_STATUS_PAUSED },
390 { LPQ_SPOOLING, JOB_STATUS_SPOOLING },
391 { LPQ_PRINTING, JOB_STATUS_PRINTING },
392 { LPQ_DELETING, JOB_STATUS_DELETING },
393 { LPQ_OFFLINE, JOB_STATUS_OFFLINE },
394 { LPQ_PAPEROUT, JOB_STATUS_PAPEROUT },
395 { LPQ_PRINTED, JOB_STATUS_PRINTED },
396 { LPQ_DELETED, JOB_STATUS_DELETED },
397 { LPQ_BLOCKED, JOB_STATUS_BLOCKED },
398 { LPQ_USER_INTERVENTION, JOB_STATUS_USER_INTERVENTION },
402 /* Convert a lpq status value stored in printing.tdb into the
403 appropriate win32 API constant. */
405 static uint32 map_to_spoolss_status(uint32 lpq_status)
409 while (lpq_to_spoolss_status_map[i].lpq_status != -1) {
410 if (lpq_to_spoolss_status_map[i].lpq_status == lpq_status)
411 return lpq_to_spoolss_status_map[i].spoolss_status;
418 static void pjob_store_notify(int snum, uint32 jobid, struct printjob *old_data,
419 struct printjob *new_data)
421 BOOL new_job = False;
426 /* Notify the job name first */
428 if (new_job || !strequal(old_data->jobname, new_data->jobname))
429 notify_job_name(snum, jobid, new_data->jobname);
431 /* Job attributes that can't be changed. We only send
432 notification for these on a new job. */
435 notify_job_submitted(snum, jobid, new_data->starttime);
436 notify_job_username(snum, jobid, new_data->user);
439 /* Job attributes of a new job or attributes that can be
442 if (new_job || old_data->status != new_data->status)
443 notify_job_status(snum, jobid, map_to_spoolss_status(new_data->status));
445 if (new_job || old_data->size != new_data->size)
446 notify_job_total_bytes(snum, jobid, new_data->size);
448 if (new_job || old_data->page_count != new_data->page_count)
449 notify_job_total_pages(snum, jobid, new_data->page_count);
452 /****************************************************************************
453 Store a job structure back to the database.
454 ****************************************************************************/
456 static BOOL pjob_store(int snum, uint32 jobid, struct printjob *pjob)
458 TDB_DATA old_data, new_data;
460 struct tdb_print_db *pdb = get_print_db_byname(lp_const_servicename(snum));
462 int len, newlen, buflen;
470 old_data = tdb_fetch(pdb->tdb, print_key(jobid));
472 /* Doh! Now we have to pack/unpack data since the NT_DEVICEMODE was added */
479 len += tdb_pack(buf+len, buflen-len, "dddddddddffff",
481 (uint32)pjob->sysjob,
483 (uint32)pjob->starttime,
484 (uint32)pjob->status,
486 (uint32)pjob->page_count,
487 (uint32)pjob->spooled,
488 (uint32)pjob->smbjob,
494 len += pack_devicemode(pjob->nt_devmode, buf+len, buflen-len);
499 tb = (char *)Realloc(buf, len);
501 DEBUG(0,("pjob_store: failed to enlarge buffer!\n"));
508 } while ( buflen != len );
514 new_data.dsize = len;
515 ret = (tdb_store(pdb->tdb, print_key(jobid), new_data, TDB_REPLACE) == 0);
517 release_print_db(pdb);
519 /* Send notify updates for what has changed */
521 if ( ret && (old_data.dsize == 0 || old_data.dsize == sizeof(*pjob)) )
522 pjob_store_notify( snum, jobid, (struct printjob *)old_data.dptr, pjob );
525 SAFE_FREE( old_data.dptr );
531 /****************************************************************************
532 Remove a job structure from the database.
533 ****************************************************************************/
535 void pjob_delete(int snum, uint32 jobid)
537 struct printjob *pjob = print_job_find(snum, jobid);
538 uint32 job_status = 0;
539 struct tdb_print_db *pdb = get_print_db_byname(lp_const_servicename(snum));
545 DEBUG(5, ("pjob_delete(): we were asked to delete nonexistent job %u\n",
546 (unsigned int)jobid));
547 release_print_db(pdb);
551 /* Send a notification that a job has been deleted */
553 job_status = map_to_spoolss_status(pjob->status);
555 /* We must cycle through JOB_STATUS_DELETING and
556 JOB_STATUS_DELETED for the port monitor to delete the job
559 job_status |= JOB_STATUS_DELETING;
560 notify_job_status(snum, jobid, job_status);
562 job_status |= JOB_STATUS_DELETED;
563 notify_job_status(snum, jobid, job_status);
565 /* Remove from printing.tdb */
567 tdb_delete(pdb->tdb, print_key(jobid));
568 release_print_db(pdb);
569 rap_jobid_delete(snum, jobid);
572 /****************************************************************************
573 Parse a file name from the system spooler to generate a jobid.
574 ****************************************************************************/
576 static uint32 print_parse_jobid(char *fname)
580 if (strncmp(fname,PRINT_SPOOL_PREFIX,strlen(PRINT_SPOOL_PREFIX)) != 0)
582 fname += strlen(PRINT_SPOOL_PREFIX);
588 return (uint32)jobid;
591 /****************************************************************************
592 List a unix job in the print database.
593 ****************************************************************************/
595 static void print_unix_job(int snum, print_queue_struct *q, uint32 jobid)
597 struct printjob pj, *old_pj;
599 if (jobid == (uint32)-1)
600 jobid = q->job + UNIX_JOB_START;
602 /* Preserve the timestamp on an existing unix print job */
604 old_pj = print_job_find(snum, jobid);
611 pj.starttime = old_pj ? old_pj->starttime : q->time;
612 pj.status = q->status;
615 pj.smbjob = (old_pj != NULL ? True : False);
616 fstrcpy(pj.filename, old_pj ? old_pj->filename : "");
617 if (jobid < UNIX_JOB_START)
618 fstrcpy(pj.jobname, old_pj ? old_pj->jobname : "Remote Downlevel Document");
620 fstrcpy(pj.jobname, old_pj ? old_pj->jobname : q->fs_file);
621 fstrcpy(pj.user, old_pj ? old_pj->user : q->fs_user);
622 fstrcpy(pj.queuename, old_pj ? old_pj->queuename : lp_const_servicename(snum));
624 pjob_store(snum, jobid, &pj);
628 struct traverse_struct {
629 print_queue_struct *queue;
630 int qcount, snum, maxcount, total_jobs;
634 /****************************************************************************
635 Utility fn to delete any jobs that are no longer active.
636 ****************************************************************************/
638 static int traverse_fn_delete(TDB_CONTEXT *t, TDB_DATA key, TDB_DATA data, void *state)
640 struct traverse_struct *ts = (struct traverse_struct *)state;
641 struct printjob pjob;
645 if ( key.dsize != sizeof(jobid) )
648 memcpy(&jobid, key.dptr, sizeof(jobid));
649 if ( unpack_pjob( data.dptr, data.dsize, &pjob ) == -1 )
651 free_nt_devicemode( &pjob.nt_devmode );
654 if (ts->snum != lp_servicenumber(pjob.queuename)) {
655 /* this isn't for the queue we are looking at - this cannot happen with the split tdb's. JRA */
660 /* remove a unix job if it isn't in the system queue any more */
662 for (i=0;i<ts->qcount;i++) {
663 uint32 u_jobid = (ts->queue[i].job + UNIX_JOB_START);
664 if (jobid == u_jobid)
667 if (i == ts->qcount) {
668 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !smbjob\n",
669 (unsigned int)jobid ));
670 pjob_delete(ts->snum, jobid);
676 /* maybe it hasn't been spooled yet */
678 /* if a job is not spooled and the process doesn't
679 exist then kill it. This cleans up after smbd
681 if (!process_exists(pjob.pid)) {
682 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !process_exists (%u)\n",
683 (unsigned int)jobid, (unsigned int)pjob.pid ));
684 pjob_delete(ts->snum, jobid);
690 for (i=0;i<ts->qcount;i++) {
691 uint32 curr_jobid = print_parse_jobid(ts->queue[i].fs_file);
692 if (jobid == curr_jobid)
696 /* The job isn't in the system queue - we have to assume it has
697 completed, so delete the database entry. */
699 if (i == ts->qcount) {
701 /* A race can occur between the time a job is spooled and
702 when it appears in the lpq output. This happens when
703 the job is added to printing.tdb when another smbd
704 running print_queue_update() has completed a lpq and
705 is currently traversing the printing tdb and deleting jobs.
706 Don't delete the job if it was submitted after the lpq_time. */
708 if (pjob.starttime < ts->lpq_time) {
709 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to pjob.starttime (%u) < ts->lpq_time (%u)\n",
711 (unsigned int)pjob.starttime,
712 (unsigned int)ts->lpq_time ));
713 pjob_delete(ts->snum, jobid);
719 /* Save the pjob attributes we will store. */
720 ts->queue[i].job = jobid;
721 ts->queue[i].size = pjob.size;
722 ts->queue[i].page_count = pjob.page_count;
723 ts->queue[i].status = pjob.status;
724 ts->queue[i].priority = 1;
725 ts->queue[i].time = pjob.starttime;
726 fstrcpy(ts->queue[i].fs_user, pjob.user);
727 fstrcpy(ts->queue[i].fs_file, pjob.jobname);
734 /****************************************************************************
735 Check if the print queue has been updated recently enough.
736 ****************************************************************************/
738 static void print_cache_flush(int snum)
741 const char *printername = lp_const_servicename(snum);
742 struct tdb_print_db *pdb = get_print_db_byname(printername);
746 slprintf(key, sizeof(key)-1, "CACHE/%s", printername);
747 tdb_store_int32(pdb->tdb, key, -1);
748 release_print_db(pdb);
751 /****************************************************************************
752 Check if someone already thinks they are doing the update.
753 ****************************************************************************/
755 static pid_t get_updating_pid(fstring printer_name)
760 struct tdb_print_db *pdb = get_print_db_byname(printer_name);
764 slprintf(keystr, sizeof(keystr)-1, "UPDATING/%s", printer_name);
766 key.dsize = strlen(keystr);
768 data = tdb_fetch(pdb->tdb, key);
769 release_print_db(pdb);
770 if (!data.dptr || data.dsize != sizeof(pid_t)) {
771 SAFE_FREE(data.dptr);
775 memcpy(&updating_pid, data.dptr, sizeof(pid_t));
776 SAFE_FREE(data.dptr);
778 if (process_exists(updating_pid))
784 /****************************************************************************
785 Set the fact that we're doing the update, or have finished doing the update
787 ****************************************************************************/
789 static void set_updating_pid(const fstring printer_name, BOOL delete)
794 pid_t updating_pid = sys_getpid();
795 struct tdb_print_db *pdb = get_print_db_byname(printer_name);
800 slprintf(keystr, sizeof(keystr)-1, "UPDATING/%s", printer_name);
802 key.dsize = strlen(keystr);
805 tdb_delete(pdb->tdb, key);
806 release_print_db(pdb);
810 data.dptr = (void *)&updating_pid;
811 data.dsize = sizeof(pid_t);
813 tdb_store(pdb->tdb, key, data, TDB_REPLACE);
814 release_print_db(pdb);
817 /****************************************************************************
818 Sort print jobs by submittal time.
819 ****************************************************************************/
821 static int printjob_comp(print_queue_struct *j1, print_queue_struct *j2)
832 /* Sort on job start time */
834 if (j1->time == j2->time)
836 return (j1->time > j2->time) ? 1 : -1;
839 /****************************************************************************
840 Store the sorted queue representation for later portmon retrieval.
841 ****************************************************************************/
843 static void store_queue_struct(struct tdb_print_db *pdb, struct traverse_struct *pts)
846 int max_reported_jobs = lp_max_reported_jobs(pts->snum);
847 print_queue_struct *queue = pts->queue;
852 if (max_reported_jobs < pts->qcount)
853 pts->qcount = max_reported_jobs;
854 qcount = pts->qcount;
856 /* Work out the size. */
858 data.dsize += tdb_pack(NULL, 0, NULL, "d", qcount);
860 for (i = 0; i < pts->qcount; i++) {
861 data.dsize += tdb_pack(NULL, 0, "ddddddff",
862 (uint32)queue[i].job,
863 (uint32)queue[i].size,
864 (uint32)queue[i].page_count,
865 (uint32)queue[i].status,
866 (uint32)queue[i].priority,
867 (uint32)queue[i].time,
872 if ((data.dptr = malloc(data.dsize)) == NULL)
876 len += tdb_pack(data.dptr + len, data.dsize - len, "d", qcount);
877 for (i = 0; i < pts->qcount; i++) {
878 len += tdb_pack(data.dptr + len, data.dsize - len, "ddddddff",
879 (uint32)queue[i].job,
880 (uint32)queue[i].size,
881 (uint32)queue[i].page_count,
882 (uint32)queue[i].status,
883 (uint32)queue[i].priority,
884 (uint32)queue[i].time,
889 key.dptr = "INFO/linear_queue_array";
890 key.dsize = strlen(key.dptr);
891 tdb_store(pdb->tdb, key, data, TDB_REPLACE);
895 static TDB_DATA get_jobs_changed_data(struct tdb_print_db *pdb)
899 key.dptr = "INFO/jobs_changed";
900 key.dsize = strlen(key.dptr);
903 data = tdb_fetch(pdb->tdb, key);
904 if (data.dptr == NULL || data.dsize == 0 || (data.dsize % 4 != 0)) {
905 SAFE_FREE(data.dptr);
912 static void check_job_changed(int snum, TDB_DATA data, uint32 jobid)
915 unsigned int job_count = data.dsize / 4;
917 for (i = 0; i < job_count; i++) {
920 memcpy(&ch_jobid, data.dptr + (i*4), 4);
921 if (ch_jobid == jobid)
922 remove_from_jobs_changed(snum, jobid);
926 /****************************************************************************
927 Update the internal database from the system print queue for a queue.
928 ****************************************************************************/
930 static void print_queue_update(int snum)
933 print_queue_struct *queue = NULL;
934 print_status_struct status;
935 print_status_struct old_status;
936 struct printjob *pjob;
937 struct traverse_struct tstruct;
938 fstring keystr, printer_name, cachestr;
941 struct tdb_print_db *pdb;
943 fstrcpy(printer_name, lp_const_servicename(snum));
944 pdb = get_print_db_byname(printer_name);
949 * Check to see if someone else is doing this update.
950 * This is essentially a mutex on the update.
953 if (get_updating_pid(printer_name) != -1) {
954 release_print_db(pdb);
958 /* Lock the queue for the database update */
960 slprintf(keystr, sizeof(keystr) - 1, "LOCK/%s", printer_name);
961 /* Only wait 10 seconds for this. */
962 if (tdb_lock_bystring(pdb->tdb, keystr, 10) == -1) {
963 DEBUG(0,("print_queue_update: Failed to lock printer %s database\n", printer_name));
964 release_print_db(pdb);
969 * Ensure that no one else got in here.
970 * If the updating pid is still -1 then we are
974 if (get_updating_pid(printer_name) != -1) {
976 * Someone else is doing the update, exit.
978 tdb_unlock_bystring(pdb->tdb, keystr);
979 release_print_db(pdb);
984 * We're going to do the update ourselves.
987 /* Tell others we're doing the update. */
988 set_updating_pid(printer_name, False);
991 * Allow others to enter and notice we're doing
995 tdb_unlock_bystring(pdb->tdb, keystr);
998 * Update the cache time FIRST ! Stops others even
999 * attempting to get the lock and doing this
1000 * if the lpq takes a long time.
1003 slprintf(cachestr, sizeof(cachestr)-1, "CACHE/%s", printer_name);
1004 tdb_store_int32(pdb->tdb, cachestr, (int)time(NULL));
1006 /* get the current queue using the appropriate interface */
1007 ZERO_STRUCT(status);
1009 qcount = (*(current_printif->queue_get))(snum, &queue, &status);
1011 DEBUG(3, ("%d job%s in queue for %s\n", qcount, (qcount != 1) ?
1012 "s" : "", printer_name));
1014 /* Sort the queue by submission time otherwise they are displayed
1017 qsort(queue, qcount, sizeof(print_queue_struct),
1018 QSORT_CAST(printjob_comp));
1021 any job in the internal database that is marked as spooled
1022 and doesn't exist in the system queue is considered finished
1023 and removed from the database
1025 any job in the system database but not in the internal database
1026 is added as a unix job
1028 fill in any system job numbers as we go
1031 jcdata = get_jobs_changed_data(pdb);
1033 for (i=0; i<qcount; i++) {
1034 uint32 jobid = print_parse_jobid(queue[i].fs_file);
1036 if (jobid == (uint32)-1) {
1037 /* assume its a unix print job */
1038 print_unix_job(snum, &queue[i], jobid);
1042 /* we have an active SMB print job - update its status */
1043 pjob = print_job_find(snum, jobid);
1045 /* err, somethings wrong. Probably smbd was restarted
1046 with jobs in the queue. All we can do is treat them
1047 like unix jobs. Pity. */
1048 print_unix_job(snum, &queue[i], jobid);
1052 pjob->sysjob = queue[i].job;
1053 pjob->status = queue[i].status;
1054 pjob_store(snum, jobid, pjob);
1055 check_job_changed(snum, jcdata, jobid);
1058 SAFE_FREE(jcdata.dptr);
1060 /* now delete any queued entries that don't appear in the
1062 tstruct.queue = queue;
1063 tstruct.qcount = qcount;
1064 tstruct.snum = snum;
1065 tstruct.total_jobs = 0;
1066 tstruct.lpq_time = time(NULL);
1068 tdb_traverse(pdb->tdb, traverse_fn_delete, (void *)&tstruct);
1070 /* Store the linearised queue, max jobs only. */
1071 store_queue_struct(pdb, &tstruct);
1073 SAFE_FREE(tstruct.queue);
1075 DEBUG(10,("print_queue_update: printer %s INFO/total_jobs = %d\n",
1076 printer_name, tstruct.total_jobs ));
1078 tdb_store_int32(pdb->tdb, "INFO/total_jobs", tstruct.total_jobs);
1080 get_queue_status(snum, &old_status);
1081 if (old_status.qcount != qcount)
1082 DEBUG(10,("print_queue_update: queue status change %d jobs -> %d jobs for printer %s\n",
1083 old_status.qcount, qcount, printer_name ));
1085 /* store the new queue status structure */
1086 slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", printer_name);
1088 key.dsize = strlen(keystr);
1090 status.qcount = qcount;
1091 data.dptr = (void *)&status;
1092 data.dsize = sizeof(status);
1093 tdb_store(pdb->tdb, key, data, TDB_REPLACE);
1096 * Update the cache time again. We want to do this call
1097 * as little as possible...
1100 slprintf(keystr, sizeof(keystr)-1, "CACHE/%s", printer_name);
1101 tdb_store_int32(pdb->tdb, keystr, (int32)time(NULL));
1103 /* Delete our pid from the db. */
1104 set_updating_pid(printer_name, True);
1105 release_print_db(pdb);
1108 /****************************************************************************
1109 Create/Update an entry in the print tdb that will allow us to send notify
1110 updates only to interested smbd's.
1111 ****************************************************************************/
1113 BOOL print_notify_register_pid(int snum)
1116 struct tdb_print_db *pdb = NULL;
1117 TDB_CONTEXT *tdb = NULL;
1118 const char *printername;
1119 uint32 mypid = (uint32)sys_getpid();
1123 /* if (snum == -1), then the change notify request was
1124 on a print server handle and we need to register on
1129 int num_services = lp_numservices();
1132 for ( idx=0; idx<num_services; idx++ ) {
1133 if (lp_snum_ok(idx) && lp_print_ok(idx) )
1134 print_notify_register_pid(idx);
1139 else /* register for a specific printer */
1141 printername = lp_const_servicename(snum);
1142 pdb = get_print_db_byname(printername);
1148 if (tdb_lock_bystring(tdb, NOTIFY_PID_LIST_KEY, 10) == -1) {
1149 DEBUG(0,("print_notify_register_pid: Failed to lock printer %s\n",
1152 release_print_db(pdb);
1156 data = get_printer_notify_pid_list( tdb, printername, True );
1158 /* Add ourselves and increase the refcount. */
1160 for (i = 0; i < data.dsize; i += 8) {
1161 if (IVAL(data.dptr,i) == mypid) {
1162 uint32 new_refcount = IVAL(data.dptr, i+4) + 1;
1163 SIVAL(data.dptr, i+4, new_refcount);
1168 if (i == data.dsize) {
1169 /* We weren't in the list. Realloc. */
1170 data.dptr = Realloc(data.dptr, data.dsize + 8);
1172 DEBUG(0,("print_notify_register_pid: Relloc fail for printer %s\n",
1177 SIVAL(data.dptr,data.dsize - 8,mypid);
1178 SIVAL(data.dptr,data.dsize - 4,1); /* Refcount. */
1181 /* Store back the record. */
1182 if (tdb_store_by_string(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) == -1) {
1183 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1184 list for printer %s\n", printername));
1192 tdb_unlock_bystring(tdb, NOTIFY_PID_LIST_KEY);
1194 release_print_db(pdb);
1195 SAFE_FREE(data.dptr);
1199 /****************************************************************************
1200 Update an entry in the print tdb that will allow us to send notify
1201 updates only to interested smbd's.
1202 ****************************************************************************/
1204 BOOL print_notify_deregister_pid(int snum)
1207 struct tdb_print_db *pdb = NULL;
1208 TDB_CONTEXT *tdb = NULL;
1209 const char *printername;
1210 uint32 mypid = (uint32)sys_getpid();
1214 /* if ( snum == -1 ), we are deregister a print server handle
1215 which means to deregister on all print queues */
1219 int num_services = lp_numservices();
1222 for ( idx=0; idx<num_services; idx++ ) {
1223 if ( lp_snum_ok(idx) && lp_print_ok(idx) )
1224 print_notify_deregister_pid(idx);
1229 else /* deregister a specific printer */
1231 printername = lp_const_servicename(snum);
1232 pdb = get_print_db_byname(printername);
1238 if (tdb_lock_bystring(tdb, NOTIFY_PID_LIST_KEY, 10) == -1) {
1239 DEBUG(0,("print_notify_register_pid: Failed to lock \
1240 printer %s database\n", printername));
1242 release_print_db(pdb);
1246 data = get_printer_notify_pid_list( tdb, printername, True );
1248 /* Reduce refcount. Remove ourselves if zero. */
1250 for (i = 0; i < data.dsize; ) {
1251 if (IVAL(data.dptr,i) == mypid) {
1252 uint32 refcount = IVAL(data.dptr, i+4);
1256 if (refcount == 0) {
1257 if (data.dsize - i > 8)
1258 memmove( &data.dptr[i], &data.dptr[i+8], data.dsize - i - 8);
1262 SIVAL(data.dptr, i+4, refcount);
1268 if (data.dsize == 0)
1269 SAFE_FREE(data.dptr);
1271 /* Store back the record. */
1272 if (tdb_store_by_string(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) == -1) {
1273 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1274 list for printer %s\n", printername));
1282 tdb_unlock_bystring(tdb, NOTIFY_PID_LIST_KEY);
1284 release_print_db(pdb);
1285 SAFE_FREE(data.dptr);
1289 /****************************************************************************
1290 Check if a jobid is valid. It is valid if it exists in the database.
1291 ****************************************************************************/
1293 BOOL print_job_exists(int snum, uint32 jobid)
1295 struct tdb_print_db *pdb = get_print_db_byname(lp_const_servicename(snum));
1300 ret = tdb_exists(pdb->tdb, print_key(jobid));
1301 release_print_db(pdb);
1305 /****************************************************************************
1306 Give the fd used for a jobid.
1307 ****************************************************************************/
1309 int print_job_fd(int snum, uint32 jobid)
1311 struct printjob *pjob = print_job_find(snum, jobid);
1314 /* don't allow another process to get this info - it is meaningless */
1315 if (pjob->pid != local_pid)
1320 /****************************************************************************
1321 Give the filename used for a jobid.
1322 Only valid for the process doing the spooling and when the job
1323 has not been spooled.
1324 ****************************************************************************/
1326 char *print_job_fname(int snum, uint32 jobid)
1328 struct printjob *pjob = print_job_find(snum, jobid);
1329 if (!pjob || pjob->spooled || pjob->pid != local_pid)
1331 return pjob->filename;
1335 /****************************************************************************
1336 Give the filename used for a jobid.
1337 Only valid for the process doing the spooling and when the job
1338 has not been spooled.
1339 ****************************************************************************/
1341 NT_DEVICEMODE *print_job_devmode(int snum, uint32 jobid)
1343 struct printjob *pjob = print_job_find(snum, jobid);
1348 return pjob->nt_devmode;
1351 /****************************************************************************
1352 Set the place in the queue for a job.
1353 ****************************************************************************/
1355 BOOL print_job_set_place(int snum, uint32 jobid, int place)
1357 DEBUG(2,("print_job_set_place not implemented yet\n"));
1361 /****************************************************************************
1362 Set the name of a job. Only possible for owner.
1363 ****************************************************************************/
1365 BOOL print_job_set_name(int snum, uint32 jobid, char *name)
1367 struct printjob *pjob = print_job_find(snum, jobid);
1368 if (!pjob || pjob->pid != local_pid)
1371 fstrcpy(pjob->jobname, name);
1372 return pjob_store(snum, jobid, pjob);
1375 /***************************************************************************
1376 Remove a jobid from the 'jobs changed' list.
1377 ***************************************************************************/
1379 static BOOL remove_from_jobs_changed(int snum, uint32 jobid)
1381 const char *printername = lp_const_servicename(snum);
1382 struct tdb_print_db *pdb = get_print_db_byname(printername);
1384 size_t job_count, i;
1386 BOOL gotlock = False;
1388 key.dptr = "INFO/jobs_changed";
1389 key.dsize = strlen(key.dptr);
1392 if (tdb_chainlock_with_timeout(pdb->tdb, key, 5) == -1)
1397 data = tdb_fetch(pdb->tdb, key);
1399 if (data.dptr == NULL || data.dsize == 0 || (data.dsize % 4 != 0))
1402 job_count = data.dsize / 4;
1403 for (i = 0; i < job_count; i++) {
1406 memcpy(&ch_jobid, data.dptr + (i*4), 4);
1407 if (ch_jobid == jobid) {
1408 if (i < job_count -1 )
1409 memmove(data.dptr + (i*4), data.dptr + (i*4) + 4, (job_count - i - 1)*4 );
1411 if (tdb_store(pdb->tdb, key, data, TDB_REPLACE) == -1)
1421 tdb_chainunlock(pdb->tdb, key);
1422 SAFE_FREE(data.dptr);
1423 release_print_db(pdb);
1425 DEBUG(10,("remove_from_jobs_changed: removed jobid %u\n", (unsigned int)jobid ));
1427 DEBUG(10,("remove_from_jobs_changed: Failed to remove jobid %u\n", (unsigned int)jobid ));
1431 /****************************************************************************
1432 Delete a print job - don't update queue.
1433 ****************************************************************************/
1435 static BOOL print_job_delete1(int snum, uint32 jobid)
1437 struct printjob *pjob = print_job_find(snum, jobid);
1444 * If already deleting just return.
1447 if (pjob->status == LPQ_DELETING)
1450 /* Hrm - we need to be able to cope with deleting a job before it
1451 has reached the spooler. */
1453 if (pjob->sysjob == -1) {
1454 DEBUG(5, ("attempt to delete job %u not seen by lpr\n", (unsigned int)jobid));
1457 /* Set the tdb entry to be deleting. */
1459 pjob->status = LPQ_DELETING;
1460 pjob_store(snum, jobid, pjob);
1462 if (pjob->spooled && pjob->sysjob != -1)
1463 result = (*(current_printif->job_delete))(snum, pjob);
1465 remove_from_jobs_changed(snum, jobid);
1467 /* Delete the tdb entry if the delete suceeded or the job hasn't
1471 const char *printername = lp_const_servicename(snum);
1472 struct tdb_print_db *pdb = get_print_db_byname(printername);
1477 pjob_delete(snum, jobid);
1478 /* Ensure we keep a rough count of the number of total jobs... */
1479 tdb_change_int32_atomic(pdb->tdb, "INFO/total_jobs", &njobs, -1);
1480 release_print_db(pdb);
1483 return (result == 0);
1486 /****************************************************************************
1487 Return true if the current user owns the print job.
1488 ****************************************************************************/
1490 static BOOL is_owner(struct current_user *user, int snum, uint32 jobid)
1492 struct printjob *pjob = print_job_find(snum, jobid);
1498 if ((vuser = get_valid_user_struct(user->vuid)) != NULL) {
1499 return strequal(pjob->user, vuser->user.smb_name);
1501 return strequal(pjob->user, uidtoname(user->uid));
1505 /****************************************************************************
1507 ****************************************************************************/
1509 BOOL print_job_delete(struct current_user *user, int snum, uint32 jobid, WERROR *errcode)
1511 BOOL owner, deleted;
1516 owner = is_owner(user, snum, jobid);
1518 /* Check access against security descriptor or whether the user
1522 !print_access_check(user, snum, JOB_ACCESS_ADMINISTER)) {
1523 DEBUG(3, ("delete denied by security descriptor\n"));
1524 *errcode = WERR_ACCESS_DENIED;
1526 /* BEGIN_ADMIN_LOG */
1527 sys_adminlog( LOG_ERR,
1528 "Permission denied-- user not allowed to delete, \
1529 pause, or resume print job. User name: %s. Printer name: %s.",
1530 uidtoname(user->uid), PRINTERNAME(snum) );
1537 * get the spooled filename of the print job
1538 * if this works, then the file has not been spooled
1539 * to the underlying print system. Just delete the
1540 * spool file & return.
1543 if ( (fname = print_job_fname( snum, jobid )) != NULL )
1545 /* remove the spool file */
1546 DEBUG(10,("print_job_delete: Removing spool file [%s]\n", fname ));
1547 if ( unlink( fname ) == -1 ) {
1548 *errcode = map_werror_from_unix(errno);
1555 if (!print_job_delete1(snum, jobid)) {
1556 *errcode = WERR_ACCESS_DENIED;
1560 /* force update the database and say the delete failed if the
1563 print_queue_update(snum);
1565 deleted = !print_job_exists(snum, jobid);
1567 *errcode = WERR_ACCESS_DENIED;
1572 /****************************************************************************
1574 ****************************************************************************/
1576 BOOL print_job_pause(struct current_user *user, int snum, uint32 jobid, WERROR *errcode)
1578 struct printjob *pjob = print_job_find(snum, jobid);
1584 if (!pjob->spooled || pjob->sysjob == -1)
1587 if (!is_owner(user, snum, jobid) &&
1588 !print_access_check(user, snum, JOB_ACCESS_ADMINISTER)) {
1589 DEBUG(3, ("pause denied by security descriptor\n"));
1591 /* BEGIN_ADMIN_LOG */
1592 sys_adminlog( LOG_ERR,
1593 "Permission denied-- user not allowed to delete, \
1594 pause, or resume print job. User name: %s. Printer name: %s.",
1595 uidtoname(user->uid), PRINTERNAME(snum) );
1598 *errcode = WERR_ACCESS_DENIED;
1602 /* need to pause the spooled entry */
1603 ret = (*(current_printif->job_pause))(snum, pjob);
1606 *errcode = WERR_INVALID_PARAM;
1610 /* force update the database */
1611 print_cache_flush(snum);
1613 /* Send a printer notify message */
1615 notify_job_status(snum, jobid, JOB_STATUS_PAUSED);
1617 /* how do we tell if this succeeded? */
1622 /****************************************************************************
1624 ****************************************************************************/
1626 BOOL print_job_resume(struct current_user *user, int snum, uint32 jobid, WERROR *errcode)
1628 struct printjob *pjob = print_job_find(snum, jobid);
1634 if (!pjob->spooled || pjob->sysjob == -1)
1637 if (!is_owner(user, snum, jobid) &&
1638 !print_access_check(user, snum, JOB_ACCESS_ADMINISTER)) {
1639 DEBUG(3, ("resume denied by security descriptor\n"));
1640 *errcode = WERR_ACCESS_DENIED;
1642 /* BEGIN_ADMIN_LOG */
1643 sys_adminlog( LOG_ERR,
1644 "Permission denied-- user not allowed to delete, \
1645 pause, or resume print job. User name: %s. Printer name: %s.",
1646 uidtoname(user->uid), PRINTERNAME(snum) );
1651 ret = (*(current_printif->job_resume))(snum, pjob);
1654 *errcode = WERR_INVALID_PARAM;
1658 /* force update the database */
1659 print_cache_flush(snum);
1661 /* Send a printer notify message */
1663 notify_job_status(snum, jobid, JOB_STATUS_QUEUED);
1668 /****************************************************************************
1669 Write to a print file.
1670 ****************************************************************************/
1672 int print_job_write(int snum, uint32 jobid, const char *buf, int size)
1675 struct printjob *pjob = print_job_find(snum, jobid);
1679 /* don't allow another process to get this info - it is meaningless */
1680 if (pjob->pid != local_pid)
1683 return_code = write(pjob->fd, buf, size);
1684 if (return_code>0) {
1686 pjob_store(snum, jobid, pjob);
1691 /****************************************************************************
1692 Check if the print queue has been updated recently enough.
1693 ****************************************************************************/
1695 static BOOL print_cache_expired(int snum)
1698 time_t last_qscan_time, time_now = time(NULL);
1699 const char *printername = lp_const_servicename(snum);
1700 struct tdb_print_db *pdb = get_print_db_byname(printername);
1705 slprintf(key, sizeof(key), "CACHE/%s", printername);
1706 last_qscan_time = (time_t)tdb_fetch_int32(pdb->tdb, key);
1709 * Invalidate the queue for 3 reasons.
1710 * (1). last queue scan time == -1.
1711 * (2). Current time - last queue scan time > allowed cache time.
1712 * (3). last queue scan time > current time + MAX_CACHE_VALID_TIME (1 hour by default).
1713 * This last test picks up machines for which the clock has been moved
1714 * forward, an lpq scan done and then the clock moved back. Otherwise
1715 * that last lpq scan would stay around for a loooong loooong time... :-). JRA.
1718 if (last_qscan_time == ((time_t)-1) || (time_now - last_qscan_time) >= lp_lpqcachetime() ||
1719 last_qscan_time > (time_now + MAX_CACHE_VALID_TIME)) {
1720 DEBUG(3, ("print cache expired for queue %s \
1721 (last_qscan_time = %d, time now = %d, qcachetime = %d)\n", printername,
1722 (int)last_qscan_time, (int)time_now, (int)lp_lpqcachetime() ));
1723 release_print_db(pdb);
1726 release_print_db(pdb);
1730 /****************************************************************************
1731 Get the queue status - do not update if db is out of date.
1732 ****************************************************************************/
1734 static int get_queue_status(int snum, print_status_struct *status)
1738 const char *printername = lp_const_servicename(snum);
1739 struct tdb_print_db *pdb = get_print_db_byname(printername);
1746 ZERO_STRUCTP(status);
1747 slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", printername);
1749 key.dsize = strlen(keystr);
1750 data = tdb_fetch(pdb->tdb, key);
1752 if (data.dsize == sizeof(print_status_struct))
1753 memcpy(status, data.dptr, sizeof(print_status_struct));
1754 SAFE_FREE(data.dptr);
1757 len = tdb_fetch_int32(pdb->tdb, "INFO/total_jobs");
1758 release_print_db(pdb);
1759 return (len == -1 ? 0 : len);
1762 /****************************************************************************
1763 Determine the number of jobs in a queue.
1764 ****************************************************************************/
1766 int print_queue_length(int snum, print_status_struct *pstatus)
1768 print_status_struct status;
1771 /* make sure the database is up to date */
1772 if (print_cache_expired(snum))
1773 print_queue_update(snum);
1775 /* also fetch the queue status */
1776 memset(&status, 0, sizeof(status));
1777 len = get_queue_status(snum, &status);
1785 /***************************************************************************
1786 Allocate a jobid. Hold the lock for as short a time as possible.
1787 ***************************************************************************/
1789 static BOOL allocate_print_jobid(struct tdb_print_db *pdb, int snum, const char *printername, uint32 *pjobid)
1794 *pjobid = (uint32)-1;
1796 for (i = 0; i < 3; i++) {
1797 /* Lock the database - only wait 20 seconds. */
1798 if (tdb_lock_bystring(pdb->tdb, "INFO/nextjob", 20) == -1) {
1799 DEBUG(0,("allocate_print_jobid: failed to lock printing database %s\n", printername ));
1803 if (!tdb_fetch_uint32(pdb->tdb, "INFO/nextjob", &jobid)) {
1804 if (tdb_error(pdb->tdb) != TDB_ERR_NOEXIST) {
1805 DEBUG(0, ("allocate_print_jobid: failed to fetch INFO/nextjob for print queue %s\n",
1812 jobid = NEXT_JOBID(jobid);
1814 if (tdb_store_int32(pdb->tdb, "INFO/nextjob", jobid)==-1) {
1815 DEBUG(3, ("allocate_print_jobid: failed to store INFO/nextjob.\n"));
1816 tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
1820 /* We've finished with the INFO/nextjob lock. */
1821 tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
1823 if (!print_job_exists(snum, jobid))
1828 DEBUG(0, ("allocate_print_jobid: failed to allocate a print job for queue %s\n",
1830 /* Probably full... */
1835 /* Store a dummy placeholder. */
1840 if (tdb_store(pdb->tdb, print_key(jobid), dum, TDB_INSERT) == -1) {
1841 DEBUG(3, ("allocate_print_jobid: jobid (%d) failed to store placeholder.\n",
1851 /***************************************************************************
1852 Append a jobid to the 'jobs changed' list.
1853 ***************************************************************************/
1855 static BOOL add_to_jobs_changed(struct tdb_print_db *pdb, uint32 jobid)
1859 key.dptr = "INFO/jobs_changed";
1860 key.dsize = strlen(key.dptr);
1861 data.dptr = (char *)&jobid;
1864 DEBUG(10,("add_to_jobs_changed: Added jobid %u\n", (unsigned int)jobid ));
1866 return (tdb_append(pdb->tdb, key, data) == 0);
1869 /***************************************************************************
1870 Start spooling a job - return the jobid.
1871 ***************************************************************************/
1873 uint32 print_job_start(struct current_user *user, int snum, char *jobname, NT_DEVICEMODE *nt_devmode )
1877 struct printjob pjob;
1879 const char *printername = lp_const_servicename(snum);
1880 struct tdb_print_db *pdb = get_print_db_byname(printername);
1888 if (!print_access_check(user, snum, PRINTER_ACCESS_USE)) {
1889 DEBUG(3, ("print_job_start: job start denied by security descriptor\n"));
1890 release_print_db(pdb);
1894 if (!print_time_access_check(snum)) {
1895 DEBUG(3, ("print_job_start: job start denied by time check\n"));
1896 release_print_db(pdb);
1900 path = lp_pathname(snum);
1902 /* see if we have sufficient disk space */
1903 if (lp_minprintspace(snum)) {
1904 SMB_BIG_UINT dspace, dsize;
1905 if (sys_fsusage(path, &dspace, &dsize) == 0 &&
1906 dspace < 2*(SMB_BIG_UINT)lp_minprintspace(snum)) {
1907 DEBUG(3, ("print_job_start: disk space check failed.\n"));
1908 release_print_db(pdb);
1914 /* for autoloaded printers, check that the printcap entry still exists */
1915 if (lp_autoloaded(snum) && !pcap_printername_ok(lp_const_servicename(snum), NULL)) {
1916 DEBUG(3, ("print_job_start: printer name %s check failed.\n", lp_const_servicename(snum) ));
1917 release_print_db(pdb);
1922 /* Insure the maximum queue size is not violated */
1923 if ((njobs = print_queue_length(snum,NULL)) > lp_maxprintjobs(snum)) {
1924 DEBUG(3, ("print_job_start: Queue %s number of jobs (%d) larger than max printjobs per queue (%d).\n",
1925 printername, njobs, lp_maxprintjobs(snum) ));
1926 release_print_db(pdb);
1931 DEBUG(10,("print_job_start: Queue %s number of jobs (%d), max printjobs = %d\n",
1932 printername, njobs, lp_maxprintjobs(snum) ));
1934 if (!allocate_print_jobid(pdb, snum, printername, &jobid))
1937 /* create the database entry */
1941 pjob.pid = local_pid;
1944 pjob.starttime = time(NULL);
1945 pjob.status = LPQ_SPOOLING;
1947 pjob.spooled = False;
1949 pjob.nt_devmode = nt_devmode;
1951 fstrcpy(pjob.jobname, jobname);
1953 if ((vuser = get_valid_user_struct(user->vuid)) != NULL) {
1954 fstrcpy(pjob.user, vuser->user.smb_name);
1956 fstrcpy(pjob.user, uidtoname(user->uid));
1959 fstrcpy(pjob.queuename, lp_const_servicename(snum));
1961 /* we have a job entry - now create the spool file */
1962 slprintf(pjob.filename, sizeof(pjob.filename)-1, "%s/%s%.8u.XXXXXX",
1963 path, PRINT_SPOOL_PREFIX, (unsigned int)jobid);
1964 pjob.fd = smb_mkstemp(pjob.filename);
1966 if (pjob.fd == -1) {
1967 if (errno == EACCES) {
1968 /* Common setup error, force a report. */
1969 DEBUG(0, ("print_job_start: insufficient permissions \
1970 to open spool file %s.\n", pjob.filename));
1972 /* Normal case, report at level 3 and above. */
1973 DEBUG(3, ("print_job_start: can't open spool file %s,\n", pjob.filename));
1974 DEBUGADD(3, ("errno = %d (%s).\n", errno, strerror(errno)));
1979 pjob_store(snum, jobid, &pjob);
1981 /* Update the 'jobs changed' entry used by print_queue_status. */
1982 add_to_jobs_changed(pdb, jobid);
1984 /* Ensure we keep a rough count of the number of total jobs... */
1985 tdb_change_int32_atomic(pdb->tdb, "INFO/total_jobs", &njobs, 1);
1987 release_print_db(pdb);
1993 pjob_delete(snum, jobid);
1995 release_print_db(pdb);
1997 DEBUG(3, ("print_job_start: returning fail. Error = %s\n", strerror(errno) ));
2001 /****************************************************************************
2002 Update the number of pages spooled to jobid
2003 ****************************************************************************/
2005 void print_job_endpage(int snum, uint32 jobid)
2007 struct printjob *pjob = print_job_find(snum, jobid);
2010 /* don't allow another process to get this info - it is meaningless */
2011 if (pjob->pid != local_pid)
2015 pjob_store(snum, jobid, pjob);
2018 /****************************************************************************
2019 Print a file - called on closing the file. This spools the job.
2020 If normal close is false then we're tearing down the jobs - treat as an
2022 ****************************************************************************/
2024 BOOL print_job_end(int snum, uint32 jobid, BOOL normal_close)
2026 struct printjob *pjob = print_job_find(snum, jobid);
2028 SMB_STRUCT_STAT sbuf;
2033 if (pjob->spooled || pjob->pid != local_pid)
2036 if (normal_close && (sys_fstat(pjob->fd, &sbuf) == 0)) {
2037 pjob->size = sbuf.st_size;
2043 * Not a normal close or we couldn't stat the job file,
2044 * so something has gone wrong. Cleanup.
2048 DEBUG(3,("print_job_end: failed to stat file for jobid %d\n", jobid ));
2052 /* Technically, this is not quite right. If the printer has a separator
2053 * page turned on, the NT spooler prints the separator page even if the
2054 * print job is 0 bytes. 010215 JRR */
2055 if (pjob->size == 0 || pjob->status == LPQ_DELETING) {
2056 /* don't bother spooling empty files or something being deleted. */
2057 DEBUG(5,("print_job_end: canceling spool of %s (%s)\n",
2058 pjob->filename, pjob->size ? "deleted" : "zero length" ));
2059 unlink(pjob->filename);
2060 pjob_delete(snum, jobid);
2064 ret = (*(current_printif->job_submit))(snum, pjob);
2069 /* The print job has been sucessfully handed over to the back-end */
2071 pjob->spooled = True;
2072 pjob->status = LPQ_QUEUED;
2073 pjob_store(snum, jobid, pjob);
2075 /* make sure the database is up to date */
2076 if (print_cache_expired(snum))
2077 print_queue_update(snum);
2083 /* The print job was not succesfully started. Cleanup */
2084 /* Still need to add proper error return propagation! 010122:JRR */
2085 unlink(pjob->filename);
2086 pjob_delete(snum, jobid);
2087 remove_from_jobs_changed(snum, jobid);
2091 /****************************************************************************
2092 Get a snapshot of jobs in the system without traversing.
2093 ****************************************************************************/
2095 static BOOL get_stored_queue_info(struct tdb_print_db *pdb, int snum, int *pcount, print_queue_struct **ppqueue)
2097 TDB_DATA data, key, cgdata;
2098 print_queue_struct *queue = NULL;
2100 uint32 extra_count = 0;
2101 int total_count = 0;
2104 int max_reported_jobs = lp_max_reported_jobs(snum);
2107 /* make sure the database is up to date */
2108 if (print_cache_expired(snum))
2109 print_queue_update(snum);
2115 ZERO_STRUCT(cgdata);
2116 key.dptr = "INFO/linear_queue_array";
2117 key.dsize = strlen(key.dptr);
2119 /* Get the stored queue data. */
2120 data = tdb_fetch(pdb->tdb, key);
2122 if (data.dptr == NULL || data.dsize < 4)
2125 memcpy(&qcount, data.dptr, 4);
2127 /* Get the changed jobs list. */
2128 key.dptr = "INFO/jobs_changed";
2129 key.dsize = strlen(key.dptr);
2131 cgdata = tdb_fetch(pdb->tdb, key);
2132 if (cgdata.dptr != NULL && (cgdata.dsize % 4 == 0))
2133 extra_count = cgdata.dsize/4;
2135 DEBUG(5,("get_stored_queue_info: qcount = %u, extra_count = %u\n", (unsigned int)qcount, (unsigned int)extra_count));
2137 /* Allocate the queue size. */
2138 if (qcount == 0 && extra_count == 0)
2141 if ((queue = (print_queue_struct *)malloc(sizeof(print_queue_struct)*(qcount + extra_count))) == NULL)
2144 /* Retrieve the linearised queue data. */
2146 for( i = 0; i < qcount; i++) {
2147 uint32 qjob, qsize, qpage_count, qstatus, qpriority, qtime;
2148 len += tdb_unpack(data.dptr + 4 + len, data.dsize - len, NULL, "ddddddff",
2157 queue[i].job = qjob;
2158 queue[i].size = qsize;
2159 queue[i].page_count = qpage_count;
2160 queue[i].status = qstatus;
2161 queue[i].priority = qpriority;
2162 queue[i].time = qtime;
2165 total_count = qcount;
2167 /* Add in the changed jobids. */
2168 for( i = 0; i < extra_count; i++) {
2170 struct printjob *pjob;
2172 memcpy(&jobid, &cgdata.dptr[i*4], 4);
2173 DEBUG(5,("get_stored_queue_info: changed job = %u\n", (unsigned int)jobid));
2174 pjob = print_job_find(snum, jobid);
2176 DEBUG(5,("get_stored_queue_info: failed to find changed job = %u\n", (unsigned int)jobid));
2177 remove_from_jobs_changed(snum, jobid);
2181 queue[total_count].job = jobid;
2182 queue[total_count].size = pjob->size;
2183 queue[total_count].page_count = pjob->page_count;
2184 queue[total_count].status = pjob->status;
2185 queue[total_count].priority = 1;
2186 fstrcpy(queue[total_count].fs_user, pjob->user);
2187 fstrcpy(queue[total_count].fs_file, pjob->jobname);
2191 /* Sort the queue by submission time otherwise they are displayed
2194 qsort(queue, total_count, sizeof(print_queue_struct), QSORT_CAST(printjob_comp));
2196 DEBUG(5,("get_stored_queue_info: total_count = %u\n", (unsigned int)total_count));
2198 if (max_reported_jobs && total_count > max_reported_jobs)
2199 total_count = max_reported_jobs;
2202 *pcount = total_count;
2208 SAFE_FREE(data.dptr);
2209 SAFE_FREE(cgdata.dptr);
2213 /****************************************************************************
2214 Get a printer queue listing.
2215 set queue = NULL and status = NULL if you just want to update the cache
2216 ****************************************************************************/
2218 int print_queue_status(int snum,
2219 print_queue_struct **ppqueue,
2220 print_status_struct *status)
2224 const char *printername;
2225 struct tdb_print_db *pdb;
2228 /* make sure the database is up to date */
2230 if (print_cache_expired(snum))
2231 print_queue_update(snum);
2233 /* return if we are done */
2234 if ( !ppqueue || !status )
2238 printername = lp_const_servicename(snum);
2239 pdb = get_print_db_byname(printername);
2245 * Fetch the queue status. We must do this first, as there may
2246 * be no jobs in the queue.
2249 ZERO_STRUCTP(status);
2250 slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", printername);
2252 key.dsize = strlen(keystr);
2253 data = tdb_fetch(pdb->tdb, key);
2255 if (data.dsize == sizeof(*status)) {
2256 memcpy(status, data.dptr, sizeof(*status));
2258 SAFE_FREE(data.dptr);
2262 * Now, fetch the print queue information. We first count the number
2263 * of entries, and then only retrieve the queue if necessary.
2266 if (!get_stored_queue_info(pdb, snum, &count, ppqueue)) {
2267 release_print_db(pdb);
2271 release_print_db(pdb);
2275 /****************************************************************************
2277 ****************************************************************************/
2279 BOOL print_queue_pause(struct current_user *user, int snum, WERROR *errcode)
2283 if (!print_access_check(user, snum, PRINTER_ACCESS_ADMINISTER)) {
2284 *errcode = WERR_ACCESS_DENIED;
2288 ret = (*(current_printif->queue_pause))(snum);
2291 *errcode = WERR_INVALID_PARAM;
2295 /* force update the database */
2296 print_cache_flush(snum);
2298 /* Send a printer notify message */
2300 notify_printer_status(snum, PRINTER_STATUS_PAUSED);
2305 /****************************************************************************
2307 ****************************************************************************/
2309 BOOL print_queue_resume(struct current_user *user, int snum, WERROR *errcode)
2313 if (!print_access_check(user, snum, PRINTER_ACCESS_ADMINISTER)) {
2314 *errcode = WERR_ACCESS_DENIED;
2318 ret = (*(current_printif->queue_resume))(snum);
2321 *errcode = WERR_INVALID_PARAM;
2325 /* make sure the database is up to date */
2326 if (print_cache_expired(snum))
2327 print_queue_update(snum);
2329 /* Send a printer notify message */
2331 notify_printer_status(snum, PRINTER_STATUS_OK);
2336 /****************************************************************************
2337 Purge a queue - implemented by deleting all jobs that we can delete.
2338 ****************************************************************************/
2340 BOOL print_queue_purge(struct current_user *user, int snum, WERROR *errcode)
2342 print_queue_struct *queue;
2343 print_status_struct status;
2347 /* Force and update so the count is accurate (i.e. not a cached count) */
2348 print_queue_update(snum);
2350 can_job_admin = print_access_check(user, snum, JOB_ACCESS_ADMINISTER);
2351 njobs = print_queue_status(snum, &queue, &status);
2353 for (i=0;i<njobs;i++) {
2354 BOOL owner = is_owner(user, snum, queue[i].job);
2356 if (owner || can_job_admin) {
2357 print_job_delete1(snum, queue[i].job);