2 Unix SMB/Netbios implementation.
4 printing backend routines
5 Copyright (C) Andrew Tridgell 1992-2000
6 Copyright (C) Jeremy Allison 2002
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 #include "librpc/gen_ndr/messaging.h"
25 #include "../librpc/gen_ndr/ndr_spoolss.h"
26 #include "nt_printing.h"
27 #include "../librpc/gen_ndr/netlogon.h"
29 extern struct current_user current_user;
30 extern userdom_struct current_user_info;
32 /* Current printer interface */
33 static bool remove_from_jobs_changed(const char* sharename, uint32 jobid);
36 the printing backend revolves around a tdb database that stores the
37 SMB view of the print queue
39 The key for this database is a jobid - a internally generated number that
40 uniquely identifies a print job
42 reading the print queue involves two steps:
43 - possibly running lpq and updating the internal database from that
44 - reading entries from the database
46 jobids are assigned when a job starts spooling.
49 static TDB_CONTEXT *rap_tdb;
50 static uint16 next_rap_jobid;
51 struct rap_jobid_key {
56 /***************************************************************************
57 Nightmare. LANMAN jobid's are 16 bit numbers..... We must map them to 32
58 bit RPC jobids.... JRA.
59 ***************************************************************************/
61 uint16 pjobid_to_rap(const char* sharename, uint32 jobid)
65 struct rap_jobid_key jinfo;
68 DEBUG(10,("pjobid_to_rap: called.\n"));
71 /* Create the in-memory tdb. */
72 rap_tdb = tdb_open_log(NULL, 0, TDB_INTERNAL, (O_RDWR|O_CREAT), 0644);
78 fstrcpy( jinfo.sharename, sharename );
80 key.dptr = (uint8 *)&jinfo;
81 key.dsize = sizeof(jinfo);
83 data = tdb_fetch(rap_tdb, key);
84 if (data.dptr && data.dsize == sizeof(uint16)) {
85 rap_jobid = SVAL(data.dptr, 0);
87 DEBUG(10,("pjobid_to_rap: jobid %u maps to RAP jobid %u\n",
88 (unsigned int)jobid, (unsigned int)rap_jobid));
92 /* Not found - create and store mapping. */
93 rap_jobid = ++next_rap_jobid;
95 rap_jobid = ++next_rap_jobid;
96 SSVAL(buf,0,rap_jobid);
98 data.dsize = sizeof(rap_jobid);
99 tdb_store(rap_tdb, key, data, TDB_REPLACE);
100 tdb_store(rap_tdb, data, key, TDB_REPLACE);
102 DEBUG(10,("pjobid_to_rap: created jobid %u maps to RAP jobid %u\n",
103 (unsigned int)jobid, (unsigned int)rap_jobid));
107 bool rap_to_pjobid(uint16 rap_jobid, fstring sharename, uint32 *pjobid)
112 DEBUG(10,("rap_to_pjobid called.\n"));
117 SSVAL(buf,0,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 if (sharename != NULL) {
125 fstrcpy( sharename, jinfo->sharename );
127 *pjobid = jinfo->jobid;
128 DEBUG(10,("rap_to_pjobid: jobid %u maps to RAP jobid %u\n",
129 (unsigned int)*pjobid, (unsigned int)rap_jobid));
130 SAFE_FREE(data.dptr);
134 DEBUG(10,("rap_to_pjobid: Failed to lookup RAP jobid %u\n",
135 (unsigned int)rap_jobid));
136 SAFE_FREE(data.dptr);
140 void rap_jobid_delete(const char* sharename, uint32 jobid)
144 struct rap_jobid_key jinfo;
147 DEBUG(10,("rap_jobid_delete: called.\n"));
152 ZERO_STRUCT( jinfo );
153 fstrcpy( jinfo.sharename, sharename );
155 key.dptr = (uint8 *)&jinfo;
156 key.dsize = sizeof(jinfo);
158 data = tdb_fetch(rap_tdb, key);
159 if (!data.dptr || (data.dsize != sizeof(uint16))) {
160 DEBUG(10,("rap_jobid_delete: cannot find jobid %u\n",
161 (unsigned int)jobid ));
162 SAFE_FREE(data.dptr);
166 DEBUG(10,("rap_jobid_delete: deleting jobid %u\n",
167 (unsigned int)jobid ));
169 rap_jobid = SVAL(data.dptr, 0);
170 SAFE_FREE(data.dptr);
171 SSVAL(buf,0,rap_jobid);
173 data.dsize = sizeof(rap_jobid);
174 tdb_delete(rap_tdb, key);
175 tdb_delete(rap_tdb, data);
178 static int get_queue_status(const char* sharename, print_status_struct *);
180 /****************************************************************************
181 Initialise the printing backend. Called once at startup before the fork().
182 ****************************************************************************/
184 bool print_backend_init(struct messaging_context *msg_ctx)
186 const char *sversion = "INFO/version";
187 int services = lp_numservices();
190 unlink(cache_path("printing.tdb"));
191 mkdir(cache_path("printing"),0755);
193 /* handle a Samba upgrade */
195 for (snum = 0; snum < services; snum++) {
196 struct tdb_print_db *pdb;
197 if (!lp_print_ok(snum))
200 pdb = get_print_db_byname(lp_const_servicename(snum));
203 if (tdb_lock_bystring(pdb->tdb, sversion) == -1) {
204 DEBUG(0,("print_backend_init: Failed to open printer %s database\n", lp_const_servicename(snum) ));
205 release_print_db(pdb);
208 if (tdb_fetch_int32(pdb->tdb, sversion) != PRINT_DATABASE_VERSION) {
209 tdb_wipe_all(pdb->tdb);
210 tdb_store_int32(pdb->tdb, sversion, PRINT_DATABASE_VERSION);
212 tdb_unlock_bystring(pdb->tdb, sversion);
213 release_print_db(pdb);
216 close_all_print_db(); /* Don't leave any open. */
218 /* do NT print initialization... */
219 return nt_printing_init(msg_ctx);
222 /****************************************************************************
223 Shut down printing backend. Called once at shutdown to close the tdb.
224 ****************************************************************************/
226 void printing_end(void)
228 close_all_print_db(); /* Don't leave any open. */
231 /****************************************************************************
232 Retrieve the set of printing functions for a given service. This allows
233 us to set the printer function table based on the value of the 'printing'
236 Use the generic interface as the default and only use cups interface only
237 when asked for (and only when supported)
238 ****************************************************************************/
240 static struct printif *get_printer_fns_from_type( enum printing_types type )
242 struct printif *printer_fns = &generic_printif;
245 if ( type == PRINT_CUPS ) {
246 printer_fns = &cups_printif;
248 #endif /* HAVE_CUPS */
251 if ( type == PRINT_IPRINT ) {
252 printer_fns = &iprint_printif;
254 #endif /* HAVE_IPRINT */
256 printer_fns->type = type;
261 static struct printif *get_printer_fns( int snum )
263 return get_printer_fns_from_type( (enum printing_types)lp_printing(snum) );
267 /****************************************************************************
268 Useful function to generate a tdb key.
269 ****************************************************************************/
271 static TDB_DATA print_key(uint32 jobid, uint32 *tmp)
275 SIVAL(tmp, 0, jobid);
276 ret.dptr = (uint8 *)tmp;
277 ret.dsize = sizeof(*tmp);
281 /****************************************************************************
282 Pack the devicemode to store it in a tdb.
283 ****************************************************************************/
284 static int pack_devicemode(struct spoolss_DeviceMode *devmode, uint8 *buf, int buflen)
286 enum ndr_err_code ndr_err;
291 ndr_err = ndr_push_struct_blob(&blob, talloc_tos(),
293 (ndr_push_flags_fn_t)
294 ndr_push_spoolss_DeviceMode);
295 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
296 DEBUG(10, ("pack_devicemode: "
297 "error encoding spoolss_DeviceMode\n"));
304 len = tdb_pack(buf, buflen, "B", blob.length, blob.data);
307 DEBUG(8, ("Packed devicemode [%s]\n", devmode->formname));
314 /****************************************************************************
315 Unpack the devicemode to store it in a tdb.
316 ****************************************************************************/
317 static int unpack_devicemode(TALLOC_CTX *mem_ctx,
318 const uint8 *buf, int buflen,
319 struct spoolss_DeviceMode **devmode)
321 struct spoolss_DeviceMode *dm;
322 enum ndr_err_code ndr_err;
330 len = tdb_unpack(buf, buflen, "B", &data_len, &data);
335 dm = talloc_zero(mem_ctx, struct spoolss_DeviceMode);
340 blob = data_blob_const(data, data_len);
342 ndr_err = ndr_pull_struct_blob(&blob, dm, dm,
343 (ndr_pull_flags_fn_t)ndr_pull_spoolss_DeviceMode);
344 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
345 DEBUG(10, ("unpack_devicemode: "
346 "error parsing spoolss_DeviceMode\n"));
350 DEBUG(8, ("Unpacked devicemode [%s](%s)\n",
351 dm->devicename, dm->formname));
352 if (dm->driverextra_data.data) {
353 DEBUG(8, ("with a private section of %d bytes\n",
354 dm->__driverextra_length));
364 /***********************************************************************
365 unpack a pjob from a tdb buffer
366 ***********************************************************************/
368 int unpack_pjob( uint8 *buf, int buflen, struct printjob *pjob )
372 uint32 pjpid, pjsysjob, pjfd, pjstarttime, pjstatus;
373 uint32 pjsize, pjpage_count, pjspooled, pjsmbjob;
378 len += tdb_unpack(buf+len, buflen-len, "dddddddddffff",
396 used = unpack_devicemode(NULL, buf+len, buflen-len, &pjob->devmode);
404 pjob->sysjob = pjsysjob;
406 pjob->starttime = pjstarttime;
407 pjob->status = pjstatus;
409 pjob->page_count = pjpage_count;
410 pjob->spooled = pjspooled;
411 pjob->smbjob = pjsmbjob;
417 /****************************************************************************
418 Useful function to find a print job in the database.
419 ****************************************************************************/
421 static struct printjob *print_job_find(const char *sharename, uint32 jobid)
423 static struct printjob pjob;
426 struct tdb_print_db *pdb = get_print_db_byname(sharename);
428 DEBUG(10,("print_job_find: looking up job %u for share %s\n",
429 (unsigned int)jobid, sharename ));
435 ret = tdb_fetch(pdb->tdb, print_key(jobid, &tmp));
436 release_print_db(pdb);
439 DEBUG(10,("print_job_find: failed to find jobid %u.\n", (unsigned int)jobid ));
443 talloc_free(pjob.devmode);
447 if ( unpack_pjob( ret.dptr, ret.dsize, &pjob ) == -1 ) {
448 DEBUG(10,("print_job_find: failed to unpack jobid %u.\n", (unsigned int)jobid ));
455 DEBUG(10,("print_job_find: returning system job %d for jobid %u.\n",
456 (int)pjob.sysjob, (unsigned int)jobid ));
461 /* Convert a unix jobid to a smb jobid */
463 struct unixjob_traverse_state {
465 uint32 sysjob_to_jobid_value;
468 static int unixjob_traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA key,
469 TDB_DATA data, void *private_data)
471 struct printjob *pjob;
472 struct unixjob_traverse_state *state =
473 (struct unixjob_traverse_state *)private_data;
475 if (!data.dptr || data.dsize == 0)
478 pjob = (struct printjob *)data.dptr;
479 if (key.dsize != sizeof(uint32))
482 if (state->sysjob == pjob->sysjob) {
483 uint32 jobid = IVAL(key.dptr,0);
485 state->sysjob_to_jobid_value = jobid;
492 /****************************************************************************
493 This is a *horribly expensive call as we have to iterate through all the
494 current printer tdb's. Don't do this often ! JRA.
495 ****************************************************************************/
497 uint32 sysjob_to_jobid(int unix_jobid)
499 int services = lp_numservices();
501 struct unixjob_traverse_state state;
503 state.sysjob = unix_jobid;
504 state.sysjob_to_jobid_value = (uint32)-1;
506 for (snum = 0; snum < services; snum++) {
507 struct tdb_print_db *pdb;
508 if (!lp_print_ok(snum))
510 pdb = get_print_db_byname(lp_const_servicename(snum));
514 tdb_traverse(pdb->tdb, unixjob_traverse_fn, &state);
515 release_print_db(pdb);
516 if (state.sysjob_to_jobid_value != (uint32)-1)
517 return state.sysjob_to_jobid_value;
522 /****************************************************************************
523 Send notifications based on what has changed after a pjob_store.
524 ****************************************************************************/
526 static const struct {
528 uint32 spoolss_status;
529 } lpq_to_spoolss_status_map[] = {
530 { LPQ_QUEUED, JOB_STATUS_QUEUED },
531 { LPQ_PAUSED, JOB_STATUS_PAUSED },
532 { LPQ_SPOOLING, JOB_STATUS_SPOOLING },
533 { LPQ_PRINTING, JOB_STATUS_PRINTING },
534 { LPQ_DELETING, JOB_STATUS_DELETING },
535 { LPQ_OFFLINE, JOB_STATUS_OFFLINE },
536 { LPQ_PAPEROUT, JOB_STATUS_PAPEROUT },
537 { LPQ_PRINTED, JOB_STATUS_PRINTED },
538 { LPQ_DELETED, JOB_STATUS_DELETED },
539 { LPQ_BLOCKED, JOB_STATUS_BLOCKED_DEVQ },
540 { LPQ_USER_INTERVENTION, JOB_STATUS_USER_INTERVENTION },
544 /* Convert a lpq status value stored in printing.tdb into the
545 appropriate win32 API constant. */
547 static uint32 map_to_spoolss_status(uint32 lpq_status)
551 while (lpq_to_spoolss_status_map[i].lpq_status != -1) {
552 if (lpq_to_spoolss_status_map[i].lpq_status == lpq_status)
553 return lpq_to_spoolss_status_map[i].spoolss_status;
560 static void pjob_store_notify(const char* sharename, uint32 jobid, struct printjob *old_data,
561 struct printjob *new_data)
563 bool new_job = False;
568 /* Job attributes that can't be changed. We only send
569 notification for these on a new job. */
571 /* ACHTUNG! Due to a bug in Samba's spoolss parsing of the
572 NOTIFY_INFO_DATA buffer, we *have* to send the job submission
573 time first or else we'll end up with potential alignment
574 errors. I don't think the systemtime should be spooled as
575 a string, but this gets us around that error.
576 --jerry (i'll feel dirty for this) */
579 notify_job_submitted(server_event_context(),
580 server_messaging_context(),
581 sharename, jobid, new_data->starttime);
582 notify_job_username(server_event_context(),
583 server_messaging_context(),
584 sharename, jobid, new_data->user);
587 if (new_job || !strequal(old_data->jobname, new_data->jobname))
588 notify_job_name(server_event_context(),
589 server_messaging_context(),
590 sharename, jobid, new_data->jobname);
592 /* Job attributes of a new job or attributes that can be
595 if (new_job || !strequal(old_data->jobname, new_data->jobname))
596 notify_job_name(server_event_context(),
597 server_messaging_context(),
598 sharename, jobid, new_data->jobname);
600 if (new_job || old_data->status != new_data->status)
601 notify_job_status(server_event_context(),
602 server_messaging_context(),
604 map_to_spoolss_status(new_data->status));
606 if (new_job || old_data->size != new_data->size)
607 notify_job_total_bytes(server_event_context(),
608 server_messaging_context(),
609 sharename, jobid, new_data->size);
611 if (new_job || old_data->page_count != new_data->page_count)
612 notify_job_total_pages(server_event_context(),
613 server_messaging_context(),
614 sharename, jobid, new_data->page_count);
617 /****************************************************************************
618 Store a job structure back to the database.
619 ****************************************************************************/
621 static bool pjob_store(const char* sharename, uint32 jobid, struct printjob *pjob)
624 TDB_DATA old_data, new_data;
626 struct tdb_print_db *pdb = get_print_db_byname(sharename);
628 int len, newlen, buflen;
636 old_data = tdb_fetch(pdb->tdb, print_key(jobid, &tmp));
638 /* Doh! Now we have to pack/unpack data since the NT_DEVICEMODE was added */
645 len += tdb_pack(buf+len, buflen-len, "dddddddddffff",
647 (uint32)pjob->sysjob,
649 (uint32)pjob->starttime,
650 (uint32)pjob->status,
652 (uint32)pjob->page_count,
653 (uint32)pjob->spooled,
654 (uint32)pjob->smbjob,
660 len += pack_devicemode(pjob->devmode, buf+len, buflen-len);
663 buf = (uint8 *)SMB_REALLOC(buf, len);
665 DEBUG(0,("pjob_store: failed to enlarge buffer!\n"));
670 } while ( buflen != len );
676 new_data.dsize = len;
677 ret = (tdb_store(pdb->tdb, print_key(jobid, &tmp), new_data,
680 release_print_db(pdb);
682 /* Send notify updates for what has changed */
685 struct printjob old_pjob;
687 if ( old_data.dsize )
689 if ( unpack_pjob( old_data.dptr, old_data.dsize, &old_pjob ) != -1 )
691 pjob_store_notify( sharename, jobid, &old_pjob , pjob );
692 talloc_free(old_pjob.devmode);
697 pjob_store_notify( sharename, jobid, NULL, pjob );
702 SAFE_FREE( old_data.dptr );
708 /****************************************************************************
709 Remove a job structure from the database.
710 ****************************************************************************/
712 void pjob_delete(const char* sharename, uint32 jobid)
715 struct printjob *pjob;
716 uint32 job_status = 0;
717 struct tdb_print_db *pdb;
719 pdb = get_print_db_byname( sharename );
724 pjob = print_job_find( sharename, jobid );
727 DEBUG(5, ("pjob_delete: we were asked to delete nonexistent job %u\n",
728 (unsigned int)jobid));
729 release_print_db(pdb);
733 /* We must cycle through JOB_STATUS_DELETING and
734 JOB_STATUS_DELETED for the port monitor to delete the job
737 job_status = JOB_STATUS_DELETING|JOB_STATUS_DELETED;
738 notify_job_status(server_event_context(),
739 server_messaging_context(),
740 sharename, jobid, job_status);
742 /* Remove from printing.tdb */
744 tdb_delete(pdb->tdb, print_key(jobid, &tmp));
745 remove_from_jobs_changed(sharename, jobid);
746 release_print_db( pdb );
747 rap_jobid_delete(sharename, jobid);
750 /****************************************************************************
751 List a unix job in the print database.
752 ****************************************************************************/
754 static void print_unix_job(const char *sharename, print_queue_struct *q, uint32 jobid)
756 struct printjob pj, *old_pj;
758 if (jobid == (uint32)-1)
759 jobid = q->job + UNIX_JOB_START;
761 /* Preserve the timestamp on an existing unix print job */
763 old_pj = print_job_find(sharename, jobid);
770 pj.starttime = old_pj ? old_pj->starttime : q->time;
771 pj.status = q->status;
774 fstrcpy(pj.filename, old_pj ? old_pj->filename : "");
775 if (jobid < UNIX_JOB_START) {
777 fstrcpy(pj.jobname, old_pj ? old_pj->jobname : "Remote Downlevel Document");
780 fstrcpy(pj.jobname, old_pj ? old_pj->jobname : q->fs_file);
782 fstrcpy(pj.user, old_pj ? old_pj->user : q->fs_user);
783 fstrcpy(pj.queuename, old_pj ? old_pj->queuename : sharename );
785 pjob_store(sharename, jobid, &pj);
789 struct traverse_struct {
790 print_queue_struct *queue;
791 int qcount, snum, maxcount, total_jobs;
792 const char *sharename;
794 const char *lprm_command;
795 struct printif *print_if;
798 /****************************************************************************
799 Utility fn to delete any jobs that are no longer active.
800 ****************************************************************************/
802 static int traverse_fn_delete(TDB_CONTEXT *t, TDB_DATA key, TDB_DATA data, void *state)
804 struct traverse_struct *ts = (struct traverse_struct *)state;
805 struct printjob pjob;
809 if ( key.dsize != sizeof(jobid) )
812 jobid = IVAL(key.dptr, 0);
813 if ( unpack_pjob( data.dptr, data.dsize, &pjob ) == -1 )
815 talloc_free(pjob.devmode);
819 /* remove a unix job if it isn't in the system queue any more */
821 for (i=0;i<ts->qcount;i++) {
822 uint32 u_jobid = (ts->queue[i].job + UNIX_JOB_START);
823 if (jobid == u_jobid)
826 if (i == ts->qcount) {
827 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !smbjob\n",
828 (unsigned int)jobid ));
829 pjob_delete(ts->sharename, jobid);
833 /* need to continue the the bottom of the function to
834 save the correct attributes */
837 /* maybe it hasn't been spooled yet */
839 /* if a job is not spooled and the process doesn't
840 exist then kill it. This cleans up after smbd
842 if (!process_exists_by_pid(pjob.pid)) {
843 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !process_exists (%u)\n",
844 (unsigned int)jobid, (unsigned int)pjob.pid ));
845 pjob_delete(ts->sharename, jobid);
851 /* this check only makes sense for jobs submitted from Windows clients */
854 for (i=0;i<ts->qcount;i++) {
857 if ( pjob.status == LPQ_DELETED )
860 curr_jobid = print_parse_jobid(ts->queue[i].fs_file);
862 if (jobid == curr_jobid) {
864 /* try to clean up any jobs that need to be deleted */
866 if ( pjob.status == LPQ_DELETING ) {
869 result = (*(ts->print_if->job_delete))(
870 ts->sharename, ts->lprm_command, &pjob );
873 /* if we can't delete, then reset the job status */
874 pjob.status = LPQ_QUEUED;
875 pjob_store(ts->sharename, jobid, &pjob);
878 /* if we deleted the job, the remove the tdb record */
879 pjob_delete(ts->sharename, jobid);
880 pjob.status = LPQ_DELETED;
890 /* The job isn't in the system queue - we have to assume it has
891 completed, so delete the database entry. */
893 if (i == ts->qcount) {
895 /* A race can occur between the time a job is spooled and
896 when it appears in the lpq output. This happens when
897 the job is added to printing.tdb when another smbd
898 running print_queue_update() has completed a lpq and
899 is currently traversing the printing tdb and deleting jobs.
900 Don't delete the job if it was submitted after the lpq_time. */
902 if (pjob.starttime < ts->lpq_time) {
903 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to pjob.starttime (%u) < ts->lpq_time (%u)\n",
905 (unsigned int)pjob.starttime,
906 (unsigned int)ts->lpq_time ));
907 pjob_delete(ts->sharename, jobid);
913 /* Save the pjob attributes we will store.
914 FIXME!!! This is the only place where queue->job
915 represents the SMB jobid --jerry */
917 ts->queue[i].job = jobid;
918 ts->queue[i].size = pjob.size;
919 ts->queue[i].page_count = pjob.page_count;
920 ts->queue[i].status = pjob.status;
921 ts->queue[i].priority = 1;
922 ts->queue[i].time = pjob.starttime;
923 fstrcpy(ts->queue[i].fs_user, pjob.user);
924 fstrcpy(ts->queue[i].fs_file, pjob.jobname);
931 /****************************************************************************
932 Check if the print queue has been updated recently enough.
933 ****************************************************************************/
935 static void print_cache_flush(const char *sharename)
938 struct tdb_print_db *pdb = get_print_db_byname(sharename);
942 slprintf(key, sizeof(key)-1, "CACHE/%s", sharename);
943 tdb_store_int32(pdb->tdb, key, -1);
944 release_print_db(pdb);
947 /****************************************************************************
948 Check if someone already thinks they are doing the update.
949 ****************************************************************************/
951 static pid_t get_updating_pid(const char *sharename)
956 struct tdb_print_db *pdb = get_print_db_byname(sharename);
960 slprintf(keystr, sizeof(keystr)-1, "UPDATING/%s", sharename);
961 key = string_tdb_data(keystr);
963 data = tdb_fetch(pdb->tdb, key);
964 release_print_db(pdb);
965 if (!data.dptr || data.dsize != sizeof(pid_t)) {
966 SAFE_FREE(data.dptr);
970 updating_pid = IVAL(data.dptr, 0);
971 SAFE_FREE(data.dptr);
973 if (process_exists_by_pid(updating_pid))
979 /****************************************************************************
980 Set the fact that we're doing the update, or have finished doing the update
982 ****************************************************************************/
984 static void set_updating_pid(const fstring sharename, bool updating)
989 pid_t updating_pid = sys_getpid();
992 struct tdb_print_db *pdb = get_print_db_byname(sharename);
997 slprintf(keystr, sizeof(keystr)-1, "UPDATING/%s", sharename);
998 key = string_tdb_data(keystr);
1000 DEBUG(5, ("set_updating_pid: %s updating lpq cache for print share %s\n",
1001 updating ? "" : "not ",
1005 tdb_delete(pdb->tdb, key);
1006 release_print_db(pdb);
1010 SIVAL( buffer, 0, updating_pid);
1012 data.dsize = 4; /* we always assume this is a 4 byte value */
1014 tdb_store(pdb->tdb, key, data, TDB_REPLACE);
1015 release_print_db(pdb);
1018 /****************************************************************************
1019 Sort print jobs by submittal time.
1020 ****************************************************************************/
1022 static int printjob_comp(print_queue_struct *j1, print_queue_struct *j2)
1033 /* Sort on job start time */
1035 if (j1->time == j2->time)
1037 return (j1->time > j2->time) ? 1 : -1;
1040 /****************************************************************************
1041 Store the sorted queue representation for later portmon retrieval.
1043 ****************************************************************************/
1045 static void store_queue_struct(struct tdb_print_db *pdb, struct traverse_struct *pts)
1048 int max_reported_jobs = lp_max_reported_jobs(pts->snum);
1049 print_queue_struct *queue = pts->queue;
1052 unsigned int qcount;
1054 if (max_reported_jobs && (max_reported_jobs < pts->qcount))
1055 pts->qcount = max_reported_jobs;
1058 /* Work out the size. */
1060 data.dsize += tdb_pack(NULL, 0, "d", qcount);
1062 for (i = 0; i < pts->qcount; i++) {
1063 if ( queue[i].status == LPQ_DELETED )
1067 data.dsize += tdb_pack(NULL, 0, "ddddddff",
1068 (uint32)queue[i].job,
1069 (uint32)queue[i].size,
1070 (uint32)queue[i].page_count,
1071 (uint32)queue[i].status,
1072 (uint32)queue[i].priority,
1073 (uint32)queue[i].time,
1078 if ((data.dptr = (uint8 *)SMB_MALLOC(data.dsize)) == NULL)
1082 len += tdb_pack(data.dptr + len, data.dsize - len, "d", qcount);
1083 for (i = 0; i < pts->qcount; i++) {
1084 if ( queue[i].status == LPQ_DELETED )
1087 len += tdb_pack(data.dptr + len, data.dsize - len, "ddddddff",
1088 (uint32)queue[i].job,
1089 (uint32)queue[i].size,
1090 (uint32)queue[i].page_count,
1091 (uint32)queue[i].status,
1092 (uint32)queue[i].priority,
1093 (uint32)queue[i].time,
1098 tdb_store(pdb->tdb, string_tdb_data("INFO/linear_queue_array"), data,
1100 SAFE_FREE(data.dptr);
1104 static TDB_DATA get_jobs_changed_data(struct tdb_print_db *pdb)
1110 data = tdb_fetch(pdb->tdb, string_tdb_data("INFO/jobs_changed"));
1111 if (data.dptr == NULL || data.dsize == 0 || (data.dsize % 4 != 0)) {
1112 SAFE_FREE(data.dptr);
1119 static void check_job_changed(const char *sharename, TDB_DATA data, uint32 jobid)
1122 unsigned int job_count = data.dsize / 4;
1124 for (i = 0; i < job_count; i++) {
1127 ch_jobid = IVAL(data.dptr, i*4);
1128 if (ch_jobid == jobid)
1129 remove_from_jobs_changed(sharename, jobid);
1133 /****************************************************************************
1134 Check if the print queue has been updated recently enough.
1135 ****************************************************************************/
1137 static bool print_cache_expired(const char *sharename, bool check_pending)
1140 time_t last_qscan_time, time_now = time(NULL);
1141 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1142 bool result = False;
1147 snprintf(key, sizeof(key), "CACHE/%s", sharename);
1148 last_qscan_time = (time_t)tdb_fetch_int32(pdb->tdb, key);
1151 * Invalidate the queue for 3 reasons.
1152 * (1). last queue scan time == -1.
1153 * (2). Current time - last queue scan time > allowed cache time.
1154 * (3). last queue scan time > current time + MAX_CACHE_VALID_TIME (1 hour by default).
1155 * This last test picks up machines for which the clock has been moved
1156 * forward, an lpq scan done and then the clock moved back. Otherwise
1157 * that last lpq scan would stay around for a loooong loooong time... :-). JRA.
1160 if (last_qscan_time == ((time_t)-1)
1161 || (time_now - last_qscan_time) >= lp_lpqcachetime()
1162 || last_qscan_time > (time_now + MAX_CACHE_VALID_TIME))
1165 time_t msg_pending_time;
1167 DEBUG(4, ("print_cache_expired: cache expired for queue %s "
1168 "(last_qscan_time = %d, time now = %d, qcachetime = %d)\n",
1169 sharename, (int)last_qscan_time, (int)time_now,
1170 (int)lp_lpqcachetime() ));
1172 /* check if another smbd has already sent a message to update the
1173 queue. Give the pending message one minute to clear and
1174 then send another message anyways. Make sure to check for
1175 clocks that have been run forward and then back again. */
1177 snprintf(key, sizeof(key), "MSG_PENDING/%s", sharename);
1180 && tdb_fetch_uint32( pdb->tdb, key, &u )
1181 && (msg_pending_time=u) > 0
1182 && msg_pending_time <= time_now
1183 && (time_now - msg_pending_time) < 60 )
1185 DEBUG(4,("print_cache_expired: message already pending for %s. Accepting cache\n",
1194 release_print_db(pdb);
1198 /****************************************************************************
1199 main work for updating the lpq cahe for a printer queue
1200 ****************************************************************************/
1202 static void print_queue_update_internal( const char *sharename,
1203 struct printif *current_printif,
1204 char *lpq_command, char *lprm_command )
1207 print_queue_struct *queue = NULL;
1208 print_status_struct status;
1209 print_status_struct old_status;
1210 struct printjob *pjob;
1211 struct traverse_struct tstruct;
1214 fstring keystr, cachestr;
1215 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1221 DEBUG(5,("print_queue_update_internal: printer = %s, type = %d, lpq command = [%s]\n",
1222 sharename, current_printif->type, lpq_command));
1225 * Update the cache time FIRST ! Stops others even
1226 * attempting to get the lock and doing this
1227 * if the lpq takes a long time.
1230 slprintf(cachestr, sizeof(cachestr)-1, "CACHE/%s", sharename);
1231 tdb_store_int32(pdb->tdb, cachestr, (int)time(NULL));
1233 /* get the current queue using the appropriate interface */
1234 ZERO_STRUCT(status);
1236 qcount = (*(current_printif->queue_get))(sharename,
1237 current_printif->type,
1238 lpq_command, &queue, &status);
1240 DEBUG(3, ("print_queue_update_internal: %d job%s in queue for %s\n",
1241 qcount, (qcount != 1) ? "s" : "", sharename));
1243 /* Sort the queue by submission time otherwise they are displayed
1246 TYPESAFE_QSORT(queue, qcount, printjob_comp);
1249 any job in the internal database that is marked as spooled
1250 and doesn't exist in the system queue is considered finished
1251 and removed from the database
1253 any job in the system database but not in the internal database
1254 is added as a unix job
1256 fill in any system job numbers as we go
1259 jcdata = get_jobs_changed_data(pdb);
1261 for (i=0; i<qcount; i++) {
1262 uint32 jobid = print_parse_jobid(queue[i].fs_file);
1264 if (jobid == (uint32)-1) {
1265 /* assume its a unix print job */
1266 print_unix_job(sharename, &queue[i], jobid);
1270 /* we have an active SMB print job - update its status */
1271 pjob = print_job_find(sharename, jobid);
1273 /* err, somethings wrong. Probably smbd was restarted
1274 with jobs in the queue. All we can do is treat them
1275 like unix jobs. Pity. */
1276 print_unix_job(sharename, &queue[i], jobid);
1280 pjob->sysjob = queue[i].job;
1282 /* don't reset the status on jobs to be deleted */
1284 if ( pjob->status != LPQ_DELETING )
1285 pjob->status = queue[i].status;
1287 pjob_store(sharename, jobid, pjob);
1289 check_job_changed(sharename, jcdata, jobid);
1292 SAFE_FREE(jcdata.dptr);
1294 /* now delete any queued entries that don't appear in the
1296 tstruct.queue = queue;
1297 tstruct.qcount = qcount;
1299 tstruct.total_jobs = 0;
1300 tstruct.lpq_time = time(NULL);
1301 tstruct.sharename = sharename;
1302 tstruct.lprm_command = lprm_command;
1303 tstruct.print_if = current_printif;
1305 tdb_traverse(pdb->tdb, traverse_fn_delete, (void *)&tstruct);
1307 /* Store the linearised queue, max jobs only. */
1308 store_queue_struct(pdb, &tstruct);
1310 SAFE_FREE(tstruct.queue);
1312 DEBUG(10,("print_queue_update_internal: printer %s INFO/total_jobs = %d\n",
1313 sharename, tstruct.total_jobs ));
1315 tdb_store_int32(pdb->tdb, "INFO/total_jobs", tstruct.total_jobs);
1317 get_queue_status(sharename, &old_status);
1318 if (old_status.qcount != qcount)
1319 DEBUG(10,("print_queue_update_internal: queue status change %d jobs -> %d jobs for printer %s\n",
1320 old_status.qcount, qcount, sharename));
1322 /* store the new queue status structure */
1323 slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", sharename);
1324 key = string_tdb_data(keystr);
1326 status.qcount = qcount;
1327 data.dptr = (uint8 *)&status;
1328 data.dsize = sizeof(status);
1329 tdb_store(pdb->tdb, key, data, TDB_REPLACE);
1332 * Update the cache time again. We want to do this call
1333 * as little as possible...
1336 slprintf(keystr, sizeof(keystr)-1, "CACHE/%s", sharename);
1337 tdb_store_int32(pdb->tdb, keystr, (int32)time(NULL));
1339 /* clear the msg pending record for this queue */
1341 snprintf(keystr, sizeof(keystr), "MSG_PENDING/%s", sharename);
1343 if ( !tdb_store_uint32( pdb->tdb, keystr, 0 ) ) {
1344 /* log a message but continue on */
1346 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1350 release_print_db( pdb );
1355 /****************************************************************************
1356 Update the internal database from the system print queue for a queue.
1357 obtain a lock on the print queue before proceeding (needed when mutiple
1358 smbd processes maytry to update the lpq cache concurrently).
1359 ****************************************************************************/
1361 static void print_queue_update_with_lock( const char *sharename,
1362 struct printif *current_printif,
1363 char *lpq_command, char *lprm_command )
1366 struct tdb_print_db *pdb;
1368 DEBUG(5,("print_queue_update_with_lock: printer share = %s\n", sharename));
1369 pdb = get_print_db_byname(sharename);
1373 if ( !print_cache_expired(sharename, False) ) {
1374 DEBUG(5,("print_queue_update_with_lock: print cache for %s is still ok\n", sharename));
1375 release_print_db(pdb);
1380 * Check to see if someone else is doing this update.
1381 * This is essentially a mutex on the update.
1384 if (get_updating_pid(sharename) != -1) {
1385 release_print_db(pdb);
1389 /* Lock the queue for the database update */
1391 slprintf(keystr, sizeof(keystr) - 1, "LOCK/%s", sharename);
1392 /* Only wait 10 seconds for this. */
1393 if (tdb_lock_bystring_with_timeout(pdb->tdb, keystr, 10) == -1) {
1394 DEBUG(0,("print_queue_update_with_lock: Failed to lock printer %s database\n", sharename));
1395 release_print_db(pdb);
1400 * Ensure that no one else got in here.
1401 * If the updating pid is still -1 then we are
1405 if (get_updating_pid(sharename) != -1) {
1407 * Someone else is doing the update, exit.
1409 tdb_unlock_bystring(pdb->tdb, keystr);
1410 release_print_db(pdb);
1415 * We're going to do the update ourselves.
1418 /* Tell others we're doing the update. */
1419 set_updating_pid(sharename, True);
1422 * Allow others to enter and notice we're doing
1426 tdb_unlock_bystring(pdb->tdb, keystr);
1428 /* do the main work now */
1430 print_queue_update_internal( sharename, current_printif,
1431 lpq_command, lprm_command );
1433 /* Delete our pid from the db. */
1434 set_updating_pid(sharename, False);
1435 release_print_db(pdb);
1438 /****************************************************************************
1439 this is the receive function of the background lpq updater
1440 ****************************************************************************/
1441 static void print_queue_receive(struct messaging_context *msg,
1444 struct server_id server_id,
1448 char *lpqcommand = NULL, *lprmcommand = NULL;
1452 len = tdb_unpack( (uint8 *)data->data, data->length, "fdPP",
1459 SAFE_FREE(lpqcommand);
1460 SAFE_FREE(lprmcommand);
1461 DEBUG(0,("print_queue_receive: Got invalid print queue update message\n"));
1465 print_queue_update_with_lock(sharename,
1466 get_printer_fns_from_type((enum printing_types)printing_type),
1467 lpqcommand, lprmcommand );
1469 SAFE_FREE(lpqcommand);
1470 SAFE_FREE(lprmcommand);
1474 static void printing_pause_fd_handler(struct tevent_context *ev,
1475 struct tevent_fd *fde,
1480 * If pause_pipe[1] is closed it means the parent smbd
1481 * and children exited or aborted.
1483 exit_server_cleanly(NULL);
1486 extern struct child_pid *children;
1487 extern int num_children;
1489 static void add_child_pid(pid_t pid)
1491 struct child_pid *child;
1493 child = SMB_MALLOC_P(struct child_pid);
1494 if (child == NULL) {
1495 DEBUG(0, ("Could not add child struct -- malloc failed\n"));
1499 DLIST_ADD(children, child);
1503 static pid_t background_lpq_updater_pid = -1;
1505 /****************************************************************************
1506 main thread of the background lpq updater
1507 ****************************************************************************/
1508 void start_background_queue(struct tevent_context *ev,
1509 struct messaging_context *msg_ctx)
1511 /* Use local variables for this as we don't
1512 * need to save the parent side of this, just
1513 * ensure it closes when the process exits.
1517 DEBUG(3,("start_background_queue: Starting background LPQ thread\n"));
1519 if (pipe(pause_pipe) == -1) {
1520 DEBUG(5,("start_background_queue: cannot create pipe. %s\n", strerror(errno) ));
1524 background_lpq_updater_pid = sys_fork();
1526 if (background_lpq_updater_pid == -1) {
1527 DEBUG(5,("start_background_queue: background LPQ thread failed to start. %s\n", strerror(errno) ));
1531 /* Track the printing pid along with other smbd children */
1532 add_child_pid(background_lpq_updater_pid);
1534 if(background_lpq_updater_pid == 0) {
1535 struct tevent_fd *fde;
1540 DEBUG(5,("start_background_queue: background LPQ thread started\n"));
1542 close(pause_pipe[0]);
1545 status = reinit_after_fork(msg_ctx, ev, procid_self(), true);
1547 if (!NT_STATUS_IS_OK(status)) {
1548 DEBUG(0,("reinit_after_fork() failed\n"));
1549 smb_panic("reinit_after_fork() failed");
1552 smbd_setup_sig_term_handler();
1553 smbd_setup_sig_hup_handler(ev, msg_ctx);
1555 if (!serverid_register(procid_self(),
1556 FLAG_MSG_GENERAL|FLAG_MSG_SMBD
1557 |FLAG_MSG_PRINT_GENERAL)) {
1561 if (!locking_init()) {
1565 messaging_register(msg_ctx, NULL, MSG_PRINTER_UPDATE,
1566 print_queue_receive);
1568 fde = tevent_add_fd(ev, ev, pause_pipe[1], TEVENT_FD_READ,
1569 printing_pause_fd_handler,
1572 DEBUG(0,("tevent_add_fd() failed for pause_pipe\n"));
1573 smb_panic("tevent_add_fd() failed for pause_pipe");
1576 DEBUG(5,("start_background_queue: background LPQ thread waiting for messages\n"));
1577 ret = tevent_loop_wait(ev);
1578 /* should not be reached */
1579 DEBUG(0,("background_queue: tevent_loop_wait() exited with %d - %s\n",
1580 ret, (ret == 0) ? "out of events" : strerror(errno)));
1584 close(pause_pipe[1]);
1587 /****************************************************************************
1588 update the internal database from the system print queue for a queue
1589 ****************************************************************************/
1591 static void print_queue_update(struct messaging_context *msg_ctx,
1592 int snum, bool force)
1596 char *lpqcommand = NULL;
1597 char *lprmcommand = NULL;
1598 uint8 *buffer = NULL;
1601 struct tdb_print_db *pdb;
1603 struct printif *current_printif;
1604 TALLOC_CTX *ctx = talloc_tos();
1606 fstrcpy( sharename, lp_const_servicename(snum));
1608 /* don't strip out characters like '$' from the printername */
1610 lpqcommand = talloc_string_sub2(ctx,
1611 lp_lpqcommand(snum),
1613 lp_printername(snum),
1614 false, false, false);
1618 lpqcommand = talloc_sub_advanced(ctx,
1619 lp_servicename(snum),
1620 current_user_info.unix_name,
1622 current_user.ut.gid,
1623 get_current_username(),
1624 current_user_info.domain,
1630 lprmcommand = talloc_string_sub2(ctx,
1631 lp_lprmcommand(snum),
1633 lp_printername(snum),
1634 false, false, false);
1638 lprmcommand = talloc_sub_advanced(ctx,
1639 lp_servicename(snum),
1640 current_user_info.unix_name,
1642 current_user.ut.gid,
1643 get_current_username(),
1644 current_user_info.domain,
1651 * Make sure that the background queue process exists.
1652 * Otherwise just do the update ourselves
1655 if ( force || background_lpq_updater_pid == -1 ) {
1656 DEBUG(4,("print_queue_update: updating queue [%s] myself\n", sharename));
1657 current_printif = get_printer_fns( snum );
1658 print_queue_update_with_lock( sharename, current_printif, lpqcommand, lprmcommand );
1663 type = lp_printing(snum);
1665 /* get the length */
1667 len = tdb_pack( NULL, 0, "fdPP",
1673 buffer = SMB_XMALLOC_ARRAY( uint8, len );
1675 /* now pack the buffer */
1676 newlen = tdb_pack( buffer, len, "fdPP",
1682 SMB_ASSERT( newlen == len );
1684 DEBUG(10,("print_queue_update: Sending message -> printer = %s, "
1685 "type = %d, lpq command = [%s] lprm command = [%s]\n",
1686 sharename, type, lpqcommand, lprmcommand ));
1688 /* here we set a msg pending record for other smbd processes
1689 to throttle the number of duplicate print_queue_update msgs
1692 pdb = get_print_db_byname(sharename);
1698 snprintf(key, sizeof(key), "MSG_PENDING/%s", sharename);
1700 if ( !tdb_store_uint32( pdb->tdb, key, time(NULL) ) ) {
1701 /* log a message but continue on */
1703 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1707 release_print_db( pdb );
1709 /* finally send the message */
1711 messaging_send_buf(msg_ctx, pid_to_procid(background_lpq_updater_pid),
1712 MSG_PRINTER_UPDATE, (uint8 *)buffer, len);
1714 SAFE_FREE( buffer );
1719 /****************************************************************************
1720 Create/Update an entry in the print tdb that will allow us to send notify
1721 updates only to interested smbd's.
1722 ****************************************************************************/
1724 bool print_notify_register_pid(int snum)
1727 struct tdb_print_db *pdb = NULL;
1728 TDB_CONTEXT *tdb = NULL;
1729 const char *printername;
1730 uint32 mypid = (uint32)sys_getpid();
1734 /* if (snum == -1), then the change notify request was
1735 on a print server handle and we need to register on
1740 int num_services = lp_numservices();
1743 for ( idx=0; idx<num_services; idx++ ) {
1744 if (lp_snum_ok(idx) && lp_print_ok(idx) )
1745 print_notify_register_pid(idx);
1750 else /* register for a specific printer */
1752 printername = lp_const_servicename(snum);
1753 pdb = get_print_db_byname(printername);
1759 if (tdb_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) == -1) {
1760 DEBUG(0,("print_notify_register_pid: Failed to lock printer %s\n",
1763 release_print_db(pdb);
1767 data = get_printer_notify_pid_list( tdb, printername, True );
1769 /* Add ourselves and increase the refcount. */
1771 for (i = 0; i < data.dsize; i += 8) {
1772 if (IVAL(data.dptr,i) == mypid) {
1773 uint32 new_refcount = IVAL(data.dptr, i+4) + 1;
1774 SIVAL(data.dptr, i+4, new_refcount);
1779 if (i == data.dsize) {
1780 /* We weren't in the list. Realloc. */
1781 data.dptr = (uint8 *)SMB_REALLOC(data.dptr, data.dsize + 8);
1783 DEBUG(0,("print_notify_register_pid: Relloc fail for printer %s\n",
1788 SIVAL(data.dptr,data.dsize - 8,mypid);
1789 SIVAL(data.dptr,data.dsize - 4,1); /* Refcount. */
1792 /* Store back the record. */
1793 if (tdb_store_bystring(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) == -1) {
1794 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1795 list for printer %s\n", printername));
1803 tdb_unlock_bystring(tdb, NOTIFY_PID_LIST_KEY);
1805 release_print_db(pdb);
1806 SAFE_FREE(data.dptr);
1810 /****************************************************************************
1811 Update an entry in the print tdb that will allow us to send notify
1812 updates only to interested smbd's.
1813 ****************************************************************************/
1815 bool print_notify_deregister_pid(int snum)
1818 struct tdb_print_db *pdb = NULL;
1819 TDB_CONTEXT *tdb = NULL;
1820 const char *printername;
1821 uint32 mypid = (uint32)sys_getpid();
1825 /* if ( snum == -1 ), we are deregister a print server handle
1826 which means to deregister on all print queues */
1830 int num_services = lp_numservices();
1833 for ( idx=0; idx<num_services; idx++ ) {
1834 if ( lp_snum_ok(idx) && lp_print_ok(idx) )
1835 print_notify_deregister_pid(idx);
1840 else /* deregister a specific printer */
1842 printername = lp_const_servicename(snum);
1843 pdb = get_print_db_byname(printername);
1849 if (tdb_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) == -1) {
1850 DEBUG(0,("print_notify_register_pid: Failed to lock \
1851 printer %s database\n", printername));
1853 release_print_db(pdb);
1857 data = get_printer_notify_pid_list( tdb, printername, True );
1859 /* Reduce refcount. Remove ourselves if zero. */
1861 for (i = 0; i < data.dsize; ) {
1862 if (IVAL(data.dptr,i) == mypid) {
1863 uint32 refcount = IVAL(data.dptr, i+4);
1867 if (refcount == 0) {
1868 if (data.dsize - i > 8)
1869 memmove( &data.dptr[i], &data.dptr[i+8], data.dsize - i - 8);
1873 SIVAL(data.dptr, i+4, refcount);
1879 if (data.dsize == 0)
1880 SAFE_FREE(data.dptr);
1882 /* Store back the record. */
1883 if (tdb_store_bystring(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) == -1) {
1884 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1885 list for printer %s\n", printername));
1893 tdb_unlock_bystring(tdb, NOTIFY_PID_LIST_KEY);
1895 release_print_db(pdb);
1896 SAFE_FREE(data.dptr);
1900 /****************************************************************************
1901 Check if a jobid is valid. It is valid if it exists in the database.
1902 ****************************************************************************/
1904 bool print_job_exists(const char* sharename, uint32 jobid)
1906 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1912 ret = tdb_exists(pdb->tdb, print_key(jobid, &tmp));
1913 release_print_db(pdb);
1917 /****************************************************************************
1918 Give the filename used for a jobid.
1919 Only valid for the process doing the spooling and when the job
1920 has not been spooled.
1921 ****************************************************************************/
1923 char *print_job_fname(const char* sharename, uint32 jobid)
1925 struct printjob *pjob = print_job_find(sharename, jobid);
1926 if (!pjob || pjob->spooled || pjob->pid != sys_getpid())
1928 return pjob->filename;
1932 /****************************************************************************
1933 Give the filename used for a jobid.
1934 Only valid for the process doing the spooling and when the job
1935 has not been spooled.
1936 ****************************************************************************/
1938 struct spoolss_DeviceMode *print_job_devmode(const char* sharename, uint32 jobid)
1940 struct printjob *pjob = print_job_find(sharename, jobid);
1945 return pjob->devmode;
1948 /****************************************************************************
1949 Set the name of a job. Only possible for owner.
1950 ****************************************************************************/
1952 bool print_job_set_name(const char *sharename, uint32 jobid, const char *name)
1954 struct printjob *pjob;
1956 pjob = print_job_find(sharename, jobid);
1957 if (!pjob || pjob->pid != sys_getpid())
1960 fstrcpy(pjob->jobname, name);
1961 return pjob_store(sharename, jobid, pjob);
1964 /****************************************************************************
1965 Get the name of a job. Only possible for owner.
1966 ****************************************************************************/
1968 bool print_job_get_name(TALLOC_CTX *mem_ctx, const char *sharename, uint32_t jobid, char **name)
1970 struct printjob *pjob;
1972 pjob = print_job_find(sharename, jobid);
1973 if (!pjob || pjob->pid != sys_getpid()) {
1977 *name = talloc_strdup(mem_ctx, pjob->jobname);
1986 /***************************************************************************
1987 Remove a jobid from the 'jobs changed' list.
1988 ***************************************************************************/
1990 static bool remove_from_jobs_changed(const char* sharename, uint32 jobid)
1992 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1994 size_t job_count, i;
1996 bool gotlock = False;
2004 key = string_tdb_data("INFO/jobs_changed");
2006 if (tdb_chainlock_with_timeout(pdb->tdb, key, 5) == -1)
2011 data = tdb_fetch(pdb->tdb, key);
2013 if (data.dptr == NULL || data.dsize == 0 || (data.dsize % 4 != 0))
2016 job_count = data.dsize / 4;
2017 for (i = 0; i < job_count; i++) {
2020 ch_jobid = IVAL(data.dptr, i*4);
2021 if (ch_jobid == jobid) {
2022 if (i < job_count -1 )
2023 memmove(data.dptr + (i*4), data.dptr + (i*4) + 4, (job_count - i - 1)*4 );
2025 if (tdb_store(pdb->tdb, key, data, TDB_REPLACE) == -1)
2035 tdb_chainunlock(pdb->tdb, key);
2036 SAFE_FREE(data.dptr);
2037 release_print_db(pdb);
2039 DEBUG(10,("remove_from_jobs_changed: removed jobid %u\n", (unsigned int)jobid ));
2041 DEBUG(10,("remove_from_jobs_changed: Failed to remove jobid %u\n", (unsigned int)jobid ));
2045 /****************************************************************************
2046 Delete a print job - don't update queue.
2047 ****************************************************************************/
2049 static bool print_job_delete1(int snum, uint32 jobid)
2051 const char* sharename = lp_const_servicename(snum);
2052 struct printjob *pjob = print_job_find(sharename, jobid);
2054 struct printif *current_printif = get_printer_fns( snum );
2060 * If already deleting just return.
2063 if (pjob->status == LPQ_DELETING)
2066 /* Hrm - we need to be able to cope with deleting a job before it
2067 has reached the spooler. Just mark it as LPQ_DELETING and
2068 let the print_queue_update() code rmeove the record */
2071 if (pjob->sysjob == -1) {
2072 DEBUG(5, ("attempt to delete job %u not seen by lpr\n", (unsigned int)jobid));
2075 /* Set the tdb entry to be deleting. */
2077 pjob->status = LPQ_DELETING;
2078 pjob_store(sharename, jobid, pjob);
2080 if (pjob->spooled && pjob->sysjob != -1)
2082 result = (*(current_printif->job_delete))(
2083 lp_printername(snum),
2084 lp_lprmcommand(snum),
2087 /* Delete the tdb entry if the delete succeeded or the job hasn't
2091 struct tdb_print_db *pdb = get_print_db_byname(sharename);
2096 pjob_delete(sharename, jobid);
2097 /* Ensure we keep a rough count of the number of total jobs... */
2098 tdb_change_int32_atomic(pdb->tdb, "INFO/total_jobs", &njobs, -1);
2099 release_print_db(pdb);
2103 remove_from_jobs_changed( sharename, jobid );
2105 return (result == 0);
2108 /****************************************************************************
2109 Return true if the current user owns the print job.
2110 ****************************************************************************/
2112 static bool is_owner(struct auth_serversupplied_info *server_info,
2113 const char *servicename,
2116 struct printjob *pjob = print_job_find(servicename, jobid);
2118 if (!pjob || !server_info)
2121 return strequal(pjob->user, server_info->sanitized_username);
2124 /****************************************************************************
2126 ****************************************************************************/
2128 WERROR print_job_delete(struct auth_serversupplied_info *server_info,
2129 struct messaging_context *msg_ctx,
2130 int snum, uint32_t jobid)
2132 const char* sharename = lp_const_servicename(snum);
2133 struct printjob *pjob;
2137 owner = is_owner(server_info, lp_const_servicename(snum), jobid);
2139 /* Check access against security descriptor or whether the user
2143 !print_access_check(server_info, msg_ctx, snum,
2144 JOB_ACCESS_ADMINISTER)) {
2145 DEBUG(3, ("delete denied by security descriptor\n"));
2147 /* BEGIN_ADMIN_LOG */
2148 sys_adminlog( LOG_ERR,
2149 "Permission denied-- user not allowed to delete, \
2150 pause, or resume print job. User name: %s. Printer name: %s.",
2151 uidtoname(server_info->utok.uid),
2152 lp_printername(snum) );
2155 return WERR_ACCESS_DENIED;
2159 * get the spooled filename of the print job
2160 * if this works, then the file has not been spooled
2161 * to the underlying print system. Just delete the
2162 * spool file & return.
2165 fname = print_job_fname(sharename, jobid);
2166 if (fname != NULL) {
2167 /* remove the spool file */
2168 DEBUG(10, ("print_job_delete: "
2169 "Removing spool file [%s]\n", fname));
2170 if (unlink(fname) == -1) {
2171 return map_werror_from_unix(errno);
2175 if (!print_job_delete1(snum, jobid)) {
2176 return WERR_ACCESS_DENIED;
2179 /* force update the database and say the delete failed if the
2182 print_queue_update(msg_ctx, snum, True);
2184 pjob = print_job_find(sharename, jobid);
2185 if (pjob && (pjob->status != LPQ_DELETING)) {
2186 return WERR_ACCESS_DENIED;
2189 return WERR_PRINTER_HAS_JOBS_QUEUED;
2192 /****************************************************************************
2194 ****************************************************************************/
2196 bool print_job_pause(struct auth_serversupplied_info *server_info,
2197 struct messaging_context *msg_ctx,
2198 int snum, uint32 jobid, WERROR *errcode)
2200 const char* sharename = lp_const_servicename(snum);
2201 struct printjob *pjob;
2203 struct printif *current_printif = get_printer_fns( snum );
2205 pjob = print_job_find(sharename, jobid);
2207 if (!pjob || !server_info) {
2208 DEBUG(10, ("print_job_pause: no pjob or user for jobid %u\n",
2209 (unsigned int)jobid ));
2213 if (!pjob->spooled || pjob->sysjob == -1) {
2214 DEBUG(10, ("print_job_pause: not spooled or bad sysjob = %d for jobid %u\n",
2215 (int)pjob->sysjob, (unsigned int)jobid ));
2219 if (!is_owner(server_info, lp_const_servicename(snum), jobid) &&
2220 !print_access_check(server_info, msg_ctx, snum,
2221 JOB_ACCESS_ADMINISTER)) {
2222 DEBUG(3, ("pause denied by security descriptor\n"));
2224 /* BEGIN_ADMIN_LOG */
2225 sys_adminlog( LOG_ERR,
2226 "Permission denied-- user not allowed to delete, \
2227 pause, or resume print job. User name: %s. Printer name: %s.",
2228 uidtoname(server_info->utok.uid),
2229 lp_printername(snum) );
2232 *errcode = WERR_ACCESS_DENIED;
2236 /* need to pause the spooled entry */
2237 ret = (*(current_printif->job_pause))(snum, pjob);
2240 *errcode = WERR_INVALID_PARAM;
2244 /* force update the database */
2245 print_cache_flush(lp_const_servicename(snum));
2247 /* Send a printer notify message */
2249 notify_job_status(server_event_context(), msg_ctx, sharename, jobid,
2252 /* how do we tell if this succeeded? */
2257 /****************************************************************************
2259 ****************************************************************************/
2261 bool print_job_resume(struct auth_serversupplied_info *server_info,
2262 struct messaging_context *msg_ctx,
2263 int snum, uint32 jobid, WERROR *errcode)
2265 const char *sharename = lp_const_servicename(snum);
2266 struct printjob *pjob;
2268 struct printif *current_printif = get_printer_fns( snum );
2270 pjob = print_job_find(sharename, jobid);
2272 if (!pjob || !server_info) {
2273 DEBUG(10, ("print_job_resume: no pjob or user for jobid %u\n",
2274 (unsigned int)jobid ));
2278 if (!pjob->spooled || pjob->sysjob == -1) {
2279 DEBUG(10, ("print_job_resume: not spooled or bad sysjob = %d for jobid %u\n",
2280 (int)pjob->sysjob, (unsigned int)jobid ));
2284 if (!is_owner(server_info, lp_const_servicename(snum), jobid) &&
2285 !print_access_check(server_info, msg_ctx, snum,
2286 JOB_ACCESS_ADMINISTER)) {
2287 DEBUG(3, ("resume denied by security descriptor\n"));
2288 *errcode = WERR_ACCESS_DENIED;
2290 /* BEGIN_ADMIN_LOG */
2291 sys_adminlog( LOG_ERR,
2292 "Permission denied-- user not allowed to delete, \
2293 pause, or resume print job. User name: %s. Printer name: %s.",
2294 uidtoname(server_info->utok.uid),
2295 lp_printername(snum) );
2300 ret = (*(current_printif->job_resume))(snum, pjob);
2303 *errcode = WERR_INVALID_PARAM;
2307 /* force update the database */
2308 print_cache_flush(lp_const_servicename(snum));
2310 /* Send a printer notify message */
2312 notify_job_status(server_event_context(), msg_ctx, sharename, jobid,
2318 /****************************************************************************
2319 Write to a print file.
2320 ****************************************************************************/
2322 ssize_t print_job_write(int snum, uint32 jobid, const char *buf, SMB_OFF_T pos, size_t size)
2324 const char* sharename = lp_const_servicename(snum);
2325 ssize_t return_code;
2326 struct printjob *pjob;
2328 pjob = print_job_find(sharename, jobid);
2332 /* don't allow another process to get this info - it is meaningless */
2333 if (pjob->pid != sys_getpid())
2336 /* if SMBD is spooling this can't be allowed */
2337 if (pjob->status == PJOB_SMBD_SPOOLING) {
2341 return_code = write_data_at_offset(pjob->fd, buf, size, pos);
2343 if (return_code>0) {
2345 pjob_store(sharename, jobid, pjob);
2350 /****************************************************************************
2351 Get the queue status - do not update if db is out of date.
2352 ****************************************************************************/
2354 static int get_queue_status(const char* sharename, print_status_struct *status)
2358 struct tdb_print_db *pdb = get_print_db_byname(sharename);
2362 ZERO_STRUCTP(status);
2369 fstr_sprintf(keystr, "STATUS/%s", sharename);
2370 data = tdb_fetch(pdb->tdb, string_tdb_data(keystr));
2372 if (data.dsize == sizeof(print_status_struct))
2373 /* this memcpy is ok since the status struct was
2374 not packed before storing it in the tdb */
2375 memcpy(status, data.dptr, sizeof(print_status_struct));
2376 SAFE_FREE(data.dptr);
2379 len = tdb_fetch_int32(pdb->tdb, "INFO/total_jobs");
2380 release_print_db(pdb);
2381 return (len == -1 ? 0 : len);
2384 /****************************************************************************
2385 Determine the number of jobs in a queue.
2386 ****************************************************************************/
2388 int print_queue_length(struct messaging_context *msg_ctx, int snum,
2389 print_status_struct *pstatus)
2391 const char* sharename = lp_const_servicename( snum );
2392 print_status_struct status;
2395 ZERO_STRUCT( status );
2397 /* make sure the database is up to date */
2398 if (print_cache_expired(lp_const_servicename(snum), True))
2399 print_queue_update(msg_ctx, snum, False);
2401 /* also fetch the queue status */
2402 memset(&status, 0, sizeof(status));
2403 len = get_queue_status(sharename, &status);
2411 /***************************************************************************
2412 Allocate a jobid. Hold the lock for as short a time as possible.
2413 ***************************************************************************/
2415 static WERROR allocate_print_jobid(struct tdb_print_db *pdb, int snum,
2416 const char *sharename, uint32 *pjobid)
2420 enum TDB_ERROR terr;
2423 *pjobid = (uint32)-1;
2425 for (i = 0; i < 3; i++) {
2426 /* Lock the database - only wait 20 seconds. */
2427 ret = tdb_lock_bystring_with_timeout(pdb->tdb,
2428 "INFO/nextjob", 20);
2430 DEBUG(0, ("allocate_print_jobid: "
2431 "Failed to lock printing database %s\n",
2433 terr = tdb_error(pdb->tdb);
2434 return ntstatus_to_werror(map_nt_error_from_tdb(terr));
2437 if (!tdb_fetch_uint32(pdb->tdb, "INFO/nextjob", &jobid)) {
2438 terr = tdb_error(pdb->tdb);
2439 if (terr != TDB_ERR_NOEXIST) {
2440 DEBUG(0, ("allocate_print_jobid: "
2441 "Failed to fetch INFO/nextjob "
2442 "for print queue %s\n", sharename));
2443 tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
2444 return ntstatus_to_werror(map_nt_error_from_tdb(terr));
2446 DEBUG(10, ("allocate_print_jobid: "
2447 "No existing jobid in %s\n", sharename));
2451 DEBUG(10, ("allocate_print_jobid: "
2452 "Read jobid %u from %s\n", jobid, sharename));
2454 jobid = NEXT_JOBID(jobid);
2456 ret = tdb_store_int32(pdb->tdb, "INFO/nextjob", jobid);
2458 terr = tdb_error(pdb->tdb);
2459 DEBUG(3, ("allocate_print_jobid: "
2460 "Failed to store INFO/nextjob.\n"));
2461 tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
2462 return ntstatus_to_werror(map_nt_error_from_tdb(terr));
2465 /* We've finished with the INFO/nextjob lock. */
2466 tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
2468 if (!print_job_exists(sharename, jobid)) {
2471 DEBUG(10, ("allocate_print_jobid: "
2472 "Found jobid %u in %s\n", jobid, sharename));
2476 DEBUG(0, ("allocate_print_jobid: "
2477 "Failed to allocate a print job for queue %s\n",
2479 /* Probably full... */
2480 return WERR_NO_SPOOL_SPACE;
2483 /* Store a dummy placeholder. */
2489 if (tdb_store(pdb->tdb, print_key(jobid, &tmp), dum,
2490 TDB_INSERT) == -1) {
2491 DEBUG(3, ("allocate_print_jobid: "
2492 "jobid (%d) failed to store placeholder.\n",
2494 terr = tdb_error(pdb->tdb);
2495 return ntstatus_to_werror(map_nt_error_from_tdb(terr));
2503 /***************************************************************************
2504 Append a jobid to the 'jobs changed' list.
2505 ***************************************************************************/
2507 static bool add_to_jobs_changed(struct tdb_print_db *pdb, uint32 jobid)
2512 SIVAL(&store_jobid, 0, jobid);
2513 data.dptr = (uint8 *)&store_jobid;
2516 DEBUG(10,("add_to_jobs_changed: Added jobid %u\n", (unsigned int)jobid ));
2518 return (tdb_append(pdb->tdb, string_tdb_data("INFO/jobs_changed"),
2523 /***************************************************************************
2524 Do all checks needed to determine if we can start a job.
2525 ***************************************************************************/
2527 static WERROR print_job_checks(struct auth_serversupplied_info *server_info,
2528 struct messaging_context *msg_ctx,
2529 int snum, int *njobs)
2531 const char *sharename = lp_const_servicename(snum);
2532 uint64_t dspace, dsize;
2536 if (!print_access_check(server_info, msg_ctx, snum,
2537 PRINTER_ACCESS_USE)) {
2538 DEBUG(3, ("print_job_checks: "
2539 "job start denied by security descriptor\n"));
2540 return WERR_ACCESS_DENIED;
2543 if (!print_time_access_check(server_info, msg_ctx, sharename)) {
2544 DEBUG(3, ("print_job_checks: "
2545 "job start denied by time check\n"));
2546 return WERR_ACCESS_DENIED;
2549 /* see if we have sufficient disk space */
2550 if (lp_minprintspace(snum)) {
2551 minspace = lp_minprintspace(snum);
2552 ret = sys_fsusage(lp_pathname(snum), &dspace, &dsize);
2553 if (ret == 0 && dspace < 2*minspace) {
2554 DEBUG(3, ("print_job_checks: "
2555 "disk space check failed.\n"));
2556 return WERR_NO_SPOOL_SPACE;
2560 /* for autoloaded printers, check that the printcap entry still exists */
2561 if (lp_autoloaded(snum) && !pcap_printername_ok(sharename)) {
2562 DEBUG(3, ("print_job_checks: printer name %s check failed.\n",
2564 return WERR_ACCESS_DENIED;
2567 /* Insure the maximum queue size is not violated */
2568 *njobs = print_queue_length(msg_ctx, snum, NULL);
2569 if (*njobs > lp_maxprintjobs(snum)) {
2570 DEBUG(3, ("print_job_checks: Queue %s number of jobs (%d) "
2571 "larger than max printjobs per queue (%d).\n",
2572 sharename, *njobs, lp_maxprintjobs(snum)));
2573 return WERR_NO_SPOOL_SPACE;
2579 /***************************************************************************
2581 ***************************************************************************/
2583 static WERROR print_job_spool_file(int snum, uint32_t jobid,
2584 const char *output_file,
2585 struct printjob *pjob)
2592 /* if this file is within the printer path, it means that smbd
2593 * is spooling it and will pass us control when it is finished.
2594 * Verify that the file name is ok, within path, and it is
2595 * already already there */
2597 path = lp_pathname(snum);
2599 if (strncmp(output_file, path, len) == 0 &&
2600 (output_file[len - 1] == '/' || output_file[len] == '/')) {
2602 /* verify path is not too long */
2603 if (strlen(output_file) >= sizeof(pjob->filename)) {
2604 return WERR_INVALID_NAME;
2607 /* verify that the file exists */
2608 if (sys_stat(output_file, &st, false) != 0) {
2609 return WERR_INVALID_NAME;
2612 fstrcpy(pjob->filename, output_file);
2614 DEBUG(3, ("print_job_spool_file:"
2615 "External spooling activated"));
2617 /* we do not open the file until spooling is done */
2619 pjob->status = PJOB_SMBD_SPOOLING;
2625 slprintf(pjob->filename, sizeof(pjob->filename)-1,
2626 "%s/%s%.8u.XXXXXX", lp_pathname(snum),
2627 PRINT_SPOOL_PREFIX, (unsigned int)jobid);
2628 pjob->fd = mkstemp(pjob->filename);
2630 if (pjob->fd == -1) {
2631 werr = map_werror_from_unix(errno);
2632 if (W_ERROR_EQUAL(werr, WERR_ACCESS_DENIED)) {
2633 /* Common setup error, force a report. */
2634 DEBUG(0, ("print_job_spool_file: "
2635 "insufficient permissions to open spool "
2636 "file %s.\n", pjob->filename));
2638 /* Normal case, report at level 3 and above. */
2639 DEBUG(3, ("print_job_spool_file: "
2640 "can't open spool file %s\n",
2649 /***************************************************************************
2650 Start spooling a job - return the jobid.
2651 ***************************************************************************/
2653 WERROR print_job_start(struct auth_serversupplied_info *server_info,
2654 struct messaging_context *msg_ctx,
2655 int snum, const char *docname, const char *filename,
2656 struct spoolss_DeviceMode *devmode, uint32_t *_jobid)
2660 struct printjob pjob;
2661 const char *sharename = lp_const_servicename(snum);
2662 struct tdb_print_db *pdb = get_print_db_byname(sharename);
2667 return WERR_INTERNAL_DB_CORRUPTION;
2670 path = lp_pathname(snum);
2672 werr = print_job_checks(server_info, msg_ctx, snum, &njobs);
2673 if (!W_ERROR_IS_OK(werr)) {
2674 release_print_db(pdb);
2678 DEBUG(10, ("print_job_start: "
2679 "Queue %s number of jobs (%d), max printjobs = %d\n",
2680 sharename, njobs, lp_maxprintjobs(snum)));
2682 werr = allocate_print_jobid(pdb, snum, sharename, &jobid);
2683 if (!W_ERROR_IS_OK(werr)) {
2687 /* create the database entry */
2691 pjob.pid = sys_getpid();
2694 pjob.starttime = time(NULL);
2695 pjob.status = LPQ_SPOOLING;
2697 pjob.spooled = False;
2699 pjob.devmode = devmode;
2701 fstrcpy(pjob.jobname, docname);
2703 fstrcpy(pjob.user, lp_printjob_username(snum));
2704 standard_sub_advanced(sharename, server_info->sanitized_username,
2705 path, server_info->utok.gid,
2706 server_info->sanitized_username,
2707 server_info->info3->base.domain.string,
2708 pjob.user, sizeof(pjob.user)-1);
2709 /* ensure NULL termination */
2710 pjob.user[sizeof(pjob.user)-1] = '\0';
2712 fstrcpy(pjob.queuename, lp_const_servicename(snum));
2714 /* we have a job entry - now create the spool file */
2715 werr = print_job_spool_file(snum, jobid, filename, &pjob);
2716 if (!W_ERROR_IS_OK(werr)) {
2720 pjob_store(sharename, jobid, &pjob);
2722 /* Update the 'jobs changed' entry used by print_queue_status. */
2723 add_to_jobs_changed(pdb, jobid);
2725 /* Ensure we keep a rough count of the number of total jobs... */
2726 tdb_change_int32_atomic(pdb->tdb, "INFO/total_jobs", &njobs, 1);
2728 release_print_db(pdb);
2735 pjob_delete(sharename, jobid);
2738 release_print_db(pdb);
2740 DEBUG(3, ("print_job_start: returning fail. "
2741 "Error = %s\n", win_errstr(werr)));
2745 /****************************************************************************
2746 Update the number of pages spooled to jobid
2747 ****************************************************************************/
2749 void print_job_endpage(int snum, uint32 jobid)
2751 const char* sharename = lp_const_servicename(snum);
2752 struct printjob *pjob;
2754 pjob = print_job_find(sharename, jobid);
2757 /* don't allow another process to get this info - it is meaningless */
2758 if (pjob->pid != sys_getpid())
2762 pjob_store(sharename, jobid, pjob);
2765 /****************************************************************************
2766 Print a file - called on closing the file. This spools the job.
2767 If normal close is false then we're tearing down the jobs - treat as an
2769 ****************************************************************************/
2771 NTSTATUS print_job_end(struct messaging_context *msg_ctx, int snum,
2772 uint32 jobid, enum file_close_type close_type)
2774 const char* sharename = lp_const_servicename(snum);
2775 struct printjob *pjob;
2777 SMB_STRUCT_STAT sbuf;
2778 struct printif *current_printif = get_printer_fns( snum );
2779 NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
2781 pjob = print_job_find(sharename, jobid);
2784 return NT_STATUS_PRINT_CANCELLED;
2787 if (pjob->spooled || pjob->pid != sys_getpid()) {
2788 return NT_STATUS_ACCESS_DENIED;
2791 if (close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) {
2792 if (pjob->status == PJOB_SMBD_SPOOLING) {
2793 /* take over the file now, smbd is done */
2794 if (sys_stat(pjob->filename, &sbuf, false) != 0) {
2795 status = map_nt_error_from_unix(errno);
2796 DEBUG(3, ("print_job_end: "
2797 "stat file failed for jobid %d\n",
2802 pjob->status = LPQ_SPOOLING;
2806 if ((sys_fstat(pjob->fd, &sbuf, false) != 0)) {
2807 status = map_nt_error_from_unix(errno);
2809 DEBUG(3, ("print_job_end: "
2810 "stat file failed for jobid %d\n",
2818 pjob->size = sbuf.st_ex_size;
2822 * Not a normal close, something has gone wrong. Cleanup.
2824 if (pjob->fd != -1) {
2830 /* Technically, this is not quite right. If the printer has a separator
2831 * page turned on, the NT spooler prints the separator page even if the
2832 * print job is 0 bytes. 010215 JRR */
2833 if (pjob->size == 0 || pjob->status == LPQ_DELETING) {
2834 /* don't bother spooling empty files or something being deleted. */
2835 DEBUG(5,("print_job_end: canceling spool of %s (%s)\n",
2836 pjob->filename, pjob->size ? "deleted" : "zero length" ));
2837 unlink(pjob->filename);
2838 pjob_delete(sharename, jobid);
2839 return NT_STATUS_OK;
2842 ret = (*(current_printif->job_submit))(snum, pjob);
2845 status = NT_STATUS_PRINT_CANCELLED;
2849 /* The print job has been successfully handed over to the back-end */
2851 pjob->spooled = True;
2852 pjob->status = LPQ_QUEUED;
2853 pjob_store(sharename, jobid, pjob);
2855 /* make sure the database is up to date */
2856 if (print_cache_expired(lp_const_servicename(snum), True))
2857 print_queue_update(msg_ctx, snum, False);
2859 return NT_STATUS_OK;
2863 /* The print job was not successfully started. Cleanup */
2864 /* Still need to add proper error return propagation! 010122:JRR */
2866 unlink(pjob->filename);
2867 pjob_delete(sharename, jobid);
2871 /****************************************************************************
2872 Get a snapshot of jobs in the system without traversing.
2873 ****************************************************************************/
2875 static bool get_stored_queue_info(struct messaging_context *msg_ctx,
2876 struct tdb_print_db *pdb, int snum,
2877 int *pcount, print_queue_struct **ppqueue)
2879 TDB_DATA data, cgdata;
2880 print_queue_struct *queue = NULL;
2882 uint32 extra_count = 0;
2883 int total_count = 0;
2886 int max_reported_jobs = lp_max_reported_jobs(snum);
2888 const char* sharename = lp_servicename(snum);
2890 /* make sure the database is up to date */
2891 if (print_cache_expired(lp_const_servicename(snum), True))
2892 print_queue_update(msg_ctx, snum, False);
2898 ZERO_STRUCT(cgdata);
2900 /* Get the stored queue data. */
2901 data = tdb_fetch(pdb->tdb, string_tdb_data("INFO/linear_queue_array"));
2903 if (data.dptr && data.dsize >= sizeof(qcount))
2904 len += tdb_unpack(data.dptr + len, data.dsize - len, "d", &qcount);
2906 /* Get the changed jobs list. */
2907 cgdata = tdb_fetch(pdb->tdb, string_tdb_data("INFO/jobs_changed"));
2908 if (cgdata.dptr != NULL && (cgdata.dsize % 4 == 0))
2909 extra_count = cgdata.dsize/4;
2911 DEBUG(5,("get_stored_queue_info: qcount = %u, extra_count = %u\n", (unsigned int)qcount, (unsigned int)extra_count));
2913 /* Allocate the queue size. */
2914 if (qcount == 0 && extra_count == 0)
2917 if ((queue = SMB_MALLOC_ARRAY(print_queue_struct, qcount + extra_count)) == NULL)
2920 /* Retrieve the linearised queue data. */
2922 for( i = 0; i < qcount; i++) {
2923 uint32 qjob, qsize, qpage_count, qstatus, qpriority, qtime;
2924 len += tdb_unpack(data.dptr + len, data.dsize - len, "ddddddff",
2933 queue[i].job = qjob;
2934 queue[i].size = qsize;
2935 queue[i].page_count = qpage_count;
2936 queue[i].status = qstatus;
2937 queue[i].priority = qpriority;
2938 queue[i].time = qtime;
2941 total_count = qcount;
2943 /* Add in the changed jobids. */
2944 for( i = 0; i < extra_count; i++) {
2946 struct printjob *pjob;
2948 jobid = IVAL(cgdata.dptr, i*4);
2949 DEBUG(5,("get_stored_queue_info: changed job = %u\n", (unsigned int)jobid));
2950 pjob = print_job_find(lp_const_servicename(snum), jobid);
2952 DEBUG(5,("get_stored_queue_info: failed to find changed job = %u\n", (unsigned int)jobid));
2953 remove_from_jobs_changed(sharename, jobid);
2957 queue[total_count].job = jobid;
2958 queue[total_count].size = pjob->size;
2959 queue[total_count].page_count = pjob->page_count;
2960 queue[total_count].status = pjob->status;
2961 queue[total_count].priority = 1;
2962 queue[total_count].time = pjob->starttime;
2963 fstrcpy(queue[total_count].fs_user, pjob->user);
2964 fstrcpy(queue[total_count].fs_file, pjob->jobname);
2968 /* Sort the queue by submission time otherwise they are displayed
2971 TYPESAFE_QSORT(queue, total_count, printjob_comp);
2973 DEBUG(5,("get_stored_queue_info: total_count = %u\n", (unsigned int)total_count));
2975 if (max_reported_jobs && total_count > max_reported_jobs)
2976 total_count = max_reported_jobs;
2979 *pcount = total_count;
2985 SAFE_FREE(data.dptr);
2986 SAFE_FREE(cgdata.dptr);
2990 /****************************************************************************
2991 Get a printer queue listing.
2992 set queue = NULL and status = NULL if you just want to update the cache
2993 ****************************************************************************/
2995 int print_queue_status(struct messaging_context *msg_ctx, int snum,
2996 print_queue_struct **ppqueue,
2997 print_status_struct *status)
3001 const char *sharename;
3002 struct tdb_print_db *pdb;
3005 /* make sure the database is up to date */
3007 if (print_cache_expired(lp_const_servicename(snum), True))
3008 print_queue_update(msg_ctx, snum, False);
3010 /* return if we are done */
3011 if ( !ppqueue || !status )
3015 sharename = lp_const_servicename(snum);
3016 pdb = get_print_db_byname(sharename);
3022 * Fetch the queue status. We must do this first, as there may
3023 * be no jobs in the queue.
3026 ZERO_STRUCTP(status);
3027 slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", sharename);
3028 key = string_tdb_data(keystr);
3030 data = tdb_fetch(pdb->tdb, key);
3032 if (data.dsize == sizeof(*status)) {
3033 /* this memcpy is ok since the status struct was
3034 not packed before storing it in the tdb */
3035 memcpy(status, data.dptr, sizeof(*status));
3037 SAFE_FREE(data.dptr);
3041 * Now, fetch the print queue information. We first count the number
3042 * of entries, and then only retrieve the queue if necessary.
3045 if (!get_stored_queue_info(msg_ctx, pdb, snum, &count, ppqueue)) {
3046 release_print_db(pdb);
3050 release_print_db(pdb);
3054 /****************************************************************************
3056 ****************************************************************************/
3058 WERROR print_queue_pause(struct auth_serversupplied_info *server_info,
3059 struct messaging_context *msg_ctx, int snum)
3062 struct printif *current_printif = get_printer_fns( snum );
3064 if (!print_access_check(server_info, msg_ctx, snum,
3065 PRINTER_ACCESS_ADMINISTER)) {
3066 return WERR_ACCESS_DENIED;
3072 ret = (*(current_printif->queue_pause))(snum);
3077 return WERR_INVALID_PARAM;
3080 /* force update the database */
3081 print_cache_flush(lp_const_servicename(snum));
3083 /* Send a printer notify message */
3085 notify_printer_status(server_event_context(), msg_ctx, snum,
3086 PRINTER_STATUS_PAUSED);
3091 /****************************************************************************
3093 ****************************************************************************/
3095 WERROR print_queue_resume(struct auth_serversupplied_info *server_info,
3096 struct messaging_context *msg_ctx, int snum)
3099 struct printif *current_printif = get_printer_fns( snum );
3101 if (!print_access_check(server_info, msg_ctx, snum,
3102 PRINTER_ACCESS_ADMINISTER)) {
3103 return WERR_ACCESS_DENIED;
3108 ret = (*(current_printif->queue_resume))(snum);
3113 return WERR_INVALID_PARAM;
3116 /* make sure the database is up to date */
3117 if (print_cache_expired(lp_const_servicename(snum), True))
3118 print_queue_update(msg_ctx, snum, True);
3120 /* Send a printer notify message */
3122 notify_printer_status(server_event_context(), msg_ctx, snum,
3128 /****************************************************************************
3129 Purge a queue - implemented by deleting all jobs that we can delete.
3130 ****************************************************************************/
3132 WERROR print_queue_purge(struct auth_serversupplied_info *server_info,
3133 struct messaging_context *msg_ctx, int snum)
3135 print_queue_struct *queue;
3136 print_status_struct status;
3140 /* Force and update so the count is accurate (i.e. not a cached count) */
3141 print_queue_update(msg_ctx, snum, True);
3143 can_job_admin = print_access_check(server_info,
3146 JOB_ACCESS_ADMINISTER);
3147 njobs = print_queue_status(msg_ctx, snum, &queue, &status);
3149 if ( can_job_admin )
3152 for (i=0;i<njobs;i++) {
3153 bool owner = is_owner(server_info, lp_const_servicename(snum),
3156 if (owner || can_job_admin) {
3157 print_job_delete1(snum, queue[i].job);
3161 if ( can_job_admin )
3164 /* update the cache */
3165 print_queue_update(msg_ctx, snum, True);