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(struct tevent_context *ev,
561 struct messaging_context *msg_ctx,
562 const char* sharename, uint32 jobid,
563 struct printjob *old_data,
564 struct printjob *new_data)
566 bool new_job = False;
571 /* Job attributes that can't be changed. We only send
572 notification for these on a new job. */
574 /* ACHTUNG! Due to a bug in Samba's spoolss parsing of the
575 NOTIFY_INFO_DATA buffer, we *have* to send the job submission
576 time first or else we'll end up with potential alignment
577 errors. I don't think the systemtime should be spooled as
578 a string, but this gets us around that error.
579 --jerry (i'll feel dirty for this) */
582 notify_job_submitted(ev, msg_ctx,
583 sharename, jobid, new_data->starttime);
584 notify_job_username(ev, msg_ctx,
585 sharename, jobid, new_data->user);
588 if (new_job || !strequal(old_data->jobname, new_data->jobname))
589 notify_job_name(ev, msg_ctx,
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(ev, msg_ctx,
597 sharename, jobid, new_data->jobname);
599 if (new_job || old_data->status != new_data->status)
600 notify_job_status(ev, msg_ctx,
602 map_to_spoolss_status(new_data->status));
604 if (new_job || old_data->size != new_data->size)
605 notify_job_total_bytes(ev, msg_ctx,
606 sharename, jobid, new_data->size);
608 if (new_job || old_data->page_count != new_data->page_count)
609 notify_job_total_pages(ev, msg_ctx,
610 sharename, jobid, new_data->page_count);
613 /****************************************************************************
614 Store a job structure back to the database.
615 ****************************************************************************/
617 static bool pjob_store(struct tevent_context *ev,
618 struct messaging_context *msg_ctx,
619 const char* sharename, uint32 jobid,
620 struct printjob *pjob)
623 TDB_DATA old_data, new_data;
625 struct tdb_print_db *pdb = get_print_db_byname(sharename);
627 int len, newlen, buflen;
635 old_data = tdb_fetch(pdb->tdb, print_key(jobid, &tmp));
637 /* Doh! Now we have to pack/unpack data since the NT_DEVICEMODE was added */
644 len += tdb_pack(buf+len, buflen-len, "dddddddddffff",
646 (uint32)pjob->sysjob,
648 (uint32)pjob->starttime,
649 (uint32)pjob->status,
651 (uint32)pjob->page_count,
652 (uint32)pjob->spooled,
653 (uint32)pjob->smbjob,
659 len += pack_devicemode(pjob->devmode, buf+len, buflen-len);
662 buf = (uint8 *)SMB_REALLOC(buf, len);
664 DEBUG(0,("pjob_store: failed to enlarge buffer!\n"));
669 } while ( buflen != len );
675 new_data.dsize = len;
676 ret = (tdb_store(pdb->tdb, print_key(jobid, &tmp), new_data,
679 release_print_db(pdb);
681 /* Send notify updates for what has changed */
684 struct printjob old_pjob;
686 if ( old_data.dsize )
688 if ( unpack_pjob( old_data.dptr, old_data.dsize, &old_pjob ) != -1 )
690 pjob_store_notify(server_event_context(),
692 sharename, jobid, &old_pjob,
694 talloc_free(old_pjob.devmode);
699 pjob_store_notify(server_event_context(), msg_ctx,
700 sharename, jobid, NULL, pjob);
705 SAFE_FREE( old_data.dptr );
711 /****************************************************************************
712 Remove a job structure from the database.
713 ****************************************************************************/
715 static void pjob_delete(struct tevent_context *ev,
716 struct messaging_context *msg_ctx,
717 const char* sharename, uint32 jobid)
720 struct printjob *pjob;
721 uint32 job_status = 0;
722 struct tdb_print_db *pdb;
724 pdb = get_print_db_byname( sharename );
729 pjob = print_job_find( sharename, jobid );
732 DEBUG(5, ("pjob_delete: we were asked to delete nonexistent job %u\n",
733 (unsigned int)jobid));
734 release_print_db(pdb);
738 /* We must cycle through JOB_STATUS_DELETING and
739 JOB_STATUS_DELETED for the port monitor to delete the job
742 job_status = JOB_STATUS_DELETING|JOB_STATUS_DELETED;
743 notify_job_status(ev, msg_ctx, sharename, jobid, job_status);
745 /* Remove from printing.tdb */
747 tdb_delete(pdb->tdb, print_key(jobid, &tmp));
748 remove_from_jobs_changed(sharename, jobid);
749 release_print_db( pdb );
750 rap_jobid_delete(sharename, jobid);
753 /****************************************************************************
754 List a unix job in the print database.
755 ****************************************************************************/
757 static void print_unix_job(struct tevent_context *ev,
758 struct messaging_context *msg_ctx,
759 const char *sharename, print_queue_struct *q,
762 struct printjob pj, *old_pj;
764 if (jobid == (uint32)-1)
765 jobid = q->job + UNIX_JOB_START;
767 /* Preserve the timestamp on an existing unix print job */
769 old_pj = print_job_find(sharename, jobid);
776 pj.starttime = old_pj ? old_pj->starttime : q->time;
777 pj.status = q->status;
780 fstrcpy(pj.filename, old_pj ? old_pj->filename : "");
781 if (jobid < UNIX_JOB_START) {
783 fstrcpy(pj.jobname, old_pj ? old_pj->jobname : "Remote Downlevel Document");
786 fstrcpy(pj.jobname, old_pj ? old_pj->jobname : q->fs_file);
788 fstrcpy(pj.user, old_pj ? old_pj->user : q->fs_user);
789 fstrcpy(pj.queuename, old_pj ? old_pj->queuename : sharename );
791 pjob_store(ev, msg_ctx, sharename, jobid, &pj);
795 struct traverse_struct {
796 print_queue_struct *queue;
797 int qcount, snum, maxcount, total_jobs;
798 const char *sharename;
800 const char *lprm_command;
801 struct printif *print_if;
802 struct tevent_context *ev;
803 struct messaging_context *msg_ctx;
806 /****************************************************************************
807 Utility fn to delete any jobs that are no longer active.
808 ****************************************************************************/
810 static int traverse_fn_delete(TDB_CONTEXT *t, TDB_DATA key, TDB_DATA data, void *state)
812 struct traverse_struct *ts = (struct traverse_struct *)state;
813 struct printjob pjob;
817 if ( key.dsize != sizeof(jobid) )
820 jobid = IVAL(key.dptr, 0);
821 if ( unpack_pjob( data.dptr, data.dsize, &pjob ) == -1 )
823 talloc_free(pjob.devmode);
827 /* remove a unix job if it isn't in the system queue any more */
829 for (i=0;i<ts->qcount;i++) {
830 uint32 u_jobid = (ts->queue[i].job + UNIX_JOB_START);
831 if (jobid == u_jobid)
834 if (i == ts->qcount) {
835 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !smbjob\n",
836 (unsigned int)jobid ));
837 pjob_delete(ts->ev, ts->msg_ctx,
838 ts->sharename, jobid);
842 /* need to continue the the bottom of the function to
843 save the correct attributes */
846 /* maybe it hasn't been spooled yet */
848 /* if a job is not spooled and the process doesn't
849 exist then kill it. This cleans up after smbd
851 if (!process_exists_by_pid(pjob.pid)) {
852 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !process_exists (%u)\n",
853 (unsigned int)jobid, (unsigned int)pjob.pid ));
854 pjob_delete(ts->ev, ts->msg_ctx,
855 ts->sharename, jobid);
861 /* this check only makes sense for jobs submitted from Windows clients */
864 for (i=0;i<ts->qcount;i++) {
867 if ( pjob.status == LPQ_DELETED )
870 curr_jobid = print_parse_jobid(ts->queue[i].fs_file);
872 if (jobid == curr_jobid) {
874 /* try to clean up any jobs that need to be deleted */
876 if ( pjob.status == LPQ_DELETING ) {
879 result = (*(ts->print_if->job_delete))(
880 ts->sharename, ts->lprm_command, &pjob );
883 /* if we can't delete, then reset the job status */
884 pjob.status = LPQ_QUEUED;
885 pjob_store(ts->ev, ts->msg_ctx,
886 ts->sharename, jobid, &pjob);
889 /* if we deleted the job, the remove the tdb record */
892 ts->sharename, jobid);
893 pjob.status = LPQ_DELETED;
903 /* The job isn't in the system queue - we have to assume it has
904 completed, so delete the database entry. */
906 if (i == ts->qcount) {
908 /* A race can occur between the time a job is spooled and
909 when it appears in the lpq output. This happens when
910 the job is added to printing.tdb when another smbd
911 running print_queue_update() has completed a lpq and
912 is currently traversing the printing tdb and deleting jobs.
913 Don't delete the job if it was submitted after the lpq_time. */
915 if (pjob.starttime < ts->lpq_time) {
916 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to pjob.starttime (%u) < ts->lpq_time (%u)\n",
918 (unsigned int)pjob.starttime,
919 (unsigned int)ts->lpq_time ));
920 pjob_delete(ts->ev, ts->msg_ctx,
921 ts->sharename, jobid);
927 /* Save the pjob attributes we will store.
928 FIXME!!! This is the only place where queue->job
929 represents the SMB jobid --jerry */
931 ts->queue[i].job = jobid;
932 ts->queue[i].size = pjob.size;
933 ts->queue[i].page_count = pjob.page_count;
934 ts->queue[i].status = pjob.status;
935 ts->queue[i].priority = 1;
936 ts->queue[i].time = pjob.starttime;
937 fstrcpy(ts->queue[i].fs_user, pjob.user);
938 fstrcpy(ts->queue[i].fs_file, pjob.jobname);
945 /****************************************************************************
946 Check if the print queue has been updated recently enough.
947 ****************************************************************************/
949 static void print_cache_flush(const char *sharename)
952 struct tdb_print_db *pdb = get_print_db_byname(sharename);
956 slprintf(key, sizeof(key)-1, "CACHE/%s", sharename);
957 tdb_store_int32(pdb->tdb, key, -1);
958 release_print_db(pdb);
961 /****************************************************************************
962 Check if someone already thinks they are doing the update.
963 ****************************************************************************/
965 static pid_t get_updating_pid(const char *sharename)
970 struct tdb_print_db *pdb = get_print_db_byname(sharename);
974 slprintf(keystr, sizeof(keystr)-1, "UPDATING/%s", sharename);
975 key = string_tdb_data(keystr);
977 data = tdb_fetch(pdb->tdb, key);
978 release_print_db(pdb);
979 if (!data.dptr || data.dsize != sizeof(pid_t)) {
980 SAFE_FREE(data.dptr);
984 updating_pid = IVAL(data.dptr, 0);
985 SAFE_FREE(data.dptr);
987 if (process_exists_by_pid(updating_pid))
993 /****************************************************************************
994 Set the fact that we're doing the update, or have finished doing the update
996 ****************************************************************************/
998 static void set_updating_pid(const fstring sharename, bool updating)
1003 pid_t updating_pid = sys_getpid();
1006 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1011 slprintf(keystr, sizeof(keystr)-1, "UPDATING/%s", sharename);
1012 key = string_tdb_data(keystr);
1014 DEBUG(5, ("set_updating_pid: %s updating lpq cache for print share %s\n",
1015 updating ? "" : "not ",
1019 tdb_delete(pdb->tdb, key);
1020 release_print_db(pdb);
1024 SIVAL( buffer, 0, updating_pid);
1026 data.dsize = 4; /* we always assume this is a 4 byte value */
1028 tdb_store(pdb->tdb, key, data, TDB_REPLACE);
1029 release_print_db(pdb);
1032 /****************************************************************************
1033 Sort print jobs by submittal time.
1034 ****************************************************************************/
1036 static int printjob_comp(print_queue_struct *j1, print_queue_struct *j2)
1047 /* Sort on job start time */
1049 if (j1->time == j2->time)
1051 return (j1->time > j2->time) ? 1 : -1;
1054 /****************************************************************************
1055 Store the sorted queue representation for later portmon retrieval.
1057 ****************************************************************************/
1059 static void store_queue_struct(struct tdb_print_db *pdb, struct traverse_struct *pts)
1062 int max_reported_jobs = lp_max_reported_jobs(pts->snum);
1063 print_queue_struct *queue = pts->queue;
1066 unsigned int qcount;
1068 if (max_reported_jobs && (max_reported_jobs < pts->qcount))
1069 pts->qcount = max_reported_jobs;
1072 /* Work out the size. */
1074 data.dsize += tdb_pack(NULL, 0, "d", qcount);
1076 for (i = 0; i < pts->qcount; i++) {
1077 if ( queue[i].status == LPQ_DELETED )
1081 data.dsize += tdb_pack(NULL, 0, "ddddddff",
1082 (uint32)queue[i].job,
1083 (uint32)queue[i].size,
1084 (uint32)queue[i].page_count,
1085 (uint32)queue[i].status,
1086 (uint32)queue[i].priority,
1087 (uint32)queue[i].time,
1092 if ((data.dptr = (uint8 *)SMB_MALLOC(data.dsize)) == NULL)
1096 len += tdb_pack(data.dptr + len, data.dsize - len, "d", qcount);
1097 for (i = 0; i < pts->qcount; i++) {
1098 if ( queue[i].status == LPQ_DELETED )
1101 len += tdb_pack(data.dptr + len, data.dsize - len, "ddddddff",
1102 (uint32)queue[i].job,
1103 (uint32)queue[i].size,
1104 (uint32)queue[i].page_count,
1105 (uint32)queue[i].status,
1106 (uint32)queue[i].priority,
1107 (uint32)queue[i].time,
1112 tdb_store(pdb->tdb, string_tdb_data("INFO/linear_queue_array"), data,
1114 SAFE_FREE(data.dptr);
1118 static TDB_DATA get_jobs_changed_data(struct tdb_print_db *pdb)
1124 data = tdb_fetch(pdb->tdb, string_tdb_data("INFO/jobs_changed"));
1125 if (data.dptr == NULL || data.dsize == 0 || (data.dsize % 4 != 0)) {
1126 SAFE_FREE(data.dptr);
1133 static void check_job_changed(const char *sharename, TDB_DATA data, uint32 jobid)
1136 unsigned int job_count = data.dsize / 4;
1138 for (i = 0; i < job_count; i++) {
1141 ch_jobid = IVAL(data.dptr, i*4);
1142 if (ch_jobid == jobid)
1143 remove_from_jobs_changed(sharename, jobid);
1147 /****************************************************************************
1148 Check if the print queue has been updated recently enough.
1149 ****************************************************************************/
1151 static bool print_cache_expired(const char *sharename, bool check_pending)
1154 time_t last_qscan_time, time_now = time(NULL);
1155 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1156 bool result = False;
1161 snprintf(key, sizeof(key), "CACHE/%s", sharename);
1162 last_qscan_time = (time_t)tdb_fetch_int32(pdb->tdb, key);
1165 * Invalidate the queue for 3 reasons.
1166 * (1). last queue scan time == -1.
1167 * (2). Current time - last queue scan time > allowed cache time.
1168 * (3). last queue scan time > current time + MAX_CACHE_VALID_TIME (1 hour by default).
1169 * This last test picks up machines for which the clock has been moved
1170 * forward, an lpq scan done and then the clock moved back. Otherwise
1171 * that last lpq scan would stay around for a loooong loooong time... :-). JRA.
1174 if (last_qscan_time == ((time_t)-1)
1175 || (time_now - last_qscan_time) >= lp_lpqcachetime()
1176 || last_qscan_time > (time_now + MAX_CACHE_VALID_TIME))
1179 time_t msg_pending_time;
1181 DEBUG(4, ("print_cache_expired: cache expired for queue %s "
1182 "(last_qscan_time = %d, time now = %d, qcachetime = %d)\n",
1183 sharename, (int)last_qscan_time, (int)time_now,
1184 (int)lp_lpqcachetime() ));
1186 /* check if another smbd has already sent a message to update the
1187 queue. Give the pending message one minute to clear and
1188 then send another message anyways. Make sure to check for
1189 clocks that have been run forward and then back again. */
1191 snprintf(key, sizeof(key), "MSG_PENDING/%s", sharename);
1194 && tdb_fetch_uint32( pdb->tdb, key, &u )
1195 && (msg_pending_time=u) > 0
1196 && msg_pending_time <= time_now
1197 && (time_now - msg_pending_time) < 60 )
1199 DEBUG(4,("print_cache_expired: message already pending for %s. Accepting cache\n",
1208 release_print_db(pdb);
1212 /****************************************************************************
1213 main work for updating the lpq cahe for a printer queue
1214 ****************************************************************************/
1216 static void print_queue_update_internal( struct tevent_context *ev,
1217 struct messaging_context *msg_ctx,
1218 const char *sharename,
1219 struct printif *current_printif,
1220 char *lpq_command, char *lprm_command )
1223 print_queue_struct *queue = NULL;
1224 print_status_struct status;
1225 print_status_struct old_status;
1226 struct printjob *pjob;
1227 struct traverse_struct tstruct;
1230 fstring keystr, cachestr;
1231 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1237 DEBUG(5,("print_queue_update_internal: printer = %s, type = %d, lpq command = [%s]\n",
1238 sharename, current_printif->type, lpq_command));
1241 * Update the cache time FIRST ! Stops others even
1242 * attempting to get the lock and doing this
1243 * if the lpq takes a long time.
1246 slprintf(cachestr, sizeof(cachestr)-1, "CACHE/%s", sharename);
1247 tdb_store_int32(pdb->tdb, cachestr, (int)time(NULL));
1249 /* get the current queue using the appropriate interface */
1250 ZERO_STRUCT(status);
1252 qcount = (*(current_printif->queue_get))(sharename,
1253 current_printif->type,
1254 lpq_command, &queue, &status);
1256 DEBUG(3, ("print_queue_update_internal: %d job%s in queue for %s\n",
1257 qcount, (qcount != 1) ? "s" : "", sharename));
1259 /* Sort the queue by submission time otherwise they are displayed
1262 TYPESAFE_QSORT(queue, qcount, printjob_comp);
1265 any job in the internal database that is marked as spooled
1266 and doesn't exist in the system queue is considered finished
1267 and removed from the database
1269 any job in the system database but not in the internal database
1270 is added as a unix job
1272 fill in any system job numbers as we go
1275 jcdata = get_jobs_changed_data(pdb);
1277 for (i=0; i<qcount; i++) {
1278 uint32 jobid = print_parse_jobid(queue[i].fs_file);
1280 if (jobid == (uint32)-1) {
1281 /* assume its a unix print job */
1282 print_unix_job(ev, msg_ctx,
1283 sharename, &queue[i], jobid);
1287 /* we have an active SMB print job - update its status */
1288 pjob = print_job_find(sharename, jobid);
1290 /* err, somethings wrong. Probably smbd was restarted
1291 with jobs in the queue. All we can do is treat them
1292 like unix jobs. Pity. */
1293 print_unix_job(ev, msg_ctx,
1294 sharename, &queue[i], jobid);
1298 pjob->sysjob = queue[i].job;
1300 /* don't reset the status on jobs to be deleted */
1302 if ( pjob->status != LPQ_DELETING )
1303 pjob->status = queue[i].status;
1305 pjob_store(ev, msg_ctx, sharename, jobid, pjob);
1307 check_job_changed(sharename, jcdata, jobid);
1310 SAFE_FREE(jcdata.dptr);
1312 /* now delete any queued entries that don't appear in the
1314 tstruct.queue = queue;
1315 tstruct.qcount = qcount;
1317 tstruct.total_jobs = 0;
1318 tstruct.lpq_time = time(NULL);
1319 tstruct.sharename = sharename;
1320 tstruct.lprm_command = lprm_command;
1321 tstruct.print_if = current_printif;
1323 tstruct.msg_ctx = msg_ctx;
1325 tdb_traverse(pdb->tdb, traverse_fn_delete, (void *)&tstruct);
1327 /* Store the linearised queue, max jobs only. */
1328 store_queue_struct(pdb, &tstruct);
1330 SAFE_FREE(tstruct.queue);
1332 DEBUG(10,("print_queue_update_internal: printer %s INFO/total_jobs = %d\n",
1333 sharename, tstruct.total_jobs ));
1335 tdb_store_int32(pdb->tdb, "INFO/total_jobs", tstruct.total_jobs);
1337 get_queue_status(sharename, &old_status);
1338 if (old_status.qcount != qcount)
1339 DEBUG(10,("print_queue_update_internal: queue status change %d jobs -> %d jobs for printer %s\n",
1340 old_status.qcount, qcount, sharename));
1342 /* store the new queue status structure */
1343 slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", sharename);
1344 key = string_tdb_data(keystr);
1346 status.qcount = qcount;
1347 data.dptr = (uint8 *)&status;
1348 data.dsize = sizeof(status);
1349 tdb_store(pdb->tdb, key, data, TDB_REPLACE);
1352 * Update the cache time again. We want to do this call
1353 * as little as possible...
1356 slprintf(keystr, sizeof(keystr)-1, "CACHE/%s", sharename);
1357 tdb_store_int32(pdb->tdb, keystr, (int32)time(NULL));
1359 /* clear the msg pending record for this queue */
1361 snprintf(keystr, sizeof(keystr), "MSG_PENDING/%s", sharename);
1363 if ( !tdb_store_uint32( pdb->tdb, keystr, 0 ) ) {
1364 /* log a message but continue on */
1366 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1370 release_print_db( pdb );
1375 /****************************************************************************
1376 Update the internal database from the system print queue for a queue.
1377 obtain a lock on the print queue before proceeding (needed when mutiple
1378 smbd processes maytry to update the lpq cache concurrently).
1379 ****************************************************************************/
1381 static void print_queue_update_with_lock( struct tevent_context *ev,
1382 struct messaging_context *msg_ctx,
1383 const char *sharename,
1384 struct printif *current_printif,
1385 char *lpq_command, char *lprm_command )
1388 struct tdb_print_db *pdb;
1390 DEBUG(5,("print_queue_update_with_lock: printer share = %s\n", sharename));
1391 pdb = get_print_db_byname(sharename);
1395 if ( !print_cache_expired(sharename, False) ) {
1396 DEBUG(5,("print_queue_update_with_lock: print cache for %s is still ok\n", sharename));
1397 release_print_db(pdb);
1402 * Check to see if someone else is doing this update.
1403 * This is essentially a mutex on the update.
1406 if (get_updating_pid(sharename) != -1) {
1407 release_print_db(pdb);
1411 /* Lock the queue for the database update */
1413 slprintf(keystr, sizeof(keystr) - 1, "LOCK/%s", sharename);
1414 /* Only wait 10 seconds for this. */
1415 if (tdb_lock_bystring_with_timeout(pdb->tdb, keystr, 10) == -1) {
1416 DEBUG(0,("print_queue_update_with_lock: Failed to lock printer %s database\n", sharename));
1417 release_print_db(pdb);
1422 * Ensure that no one else got in here.
1423 * If the updating pid is still -1 then we are
1427 if (get_updating_pid(sharename) != -1) {
1429 * Someone else is doing the update, exit.
1431 tdb_unlock_bystring(pdb->tdb, keystr);
1432 release_print_db(pdb);
1437 * We're going to do the update ourselves.
1440 /* Tell others we're doing the update. */
1441 set_updating_pid(sharename, True);
1444 * Allow others to enter and notice we're doing
1448 tdb_unlock_bystring(pdb->tdb, keystr);
1450 /* do the main work now */
1452 print_queue_update_internal(ev, msg_ctx,
1453 sharename, current_printif,
1454 lpq_command, lprm_command);
1456 /* Delete our pid from the db. */
1457 set_updating_pid(sharename, False);
1458 release_print_db(pdb);
1461 /****************************************************************************
1462 this is the receive function of the background lpq updater
1463 ****************************************************************************/
1464 static void print_queue_receive(struct messaging_context *msg,
1467 struct server_id server_id,
1471 char *lpqcommand = NULL, *lprmcommand = NULL;
1475 len = tdb_unpack( (uint8 *)data->data, data->length, "fdPP",
1482 SAFE_FREE(lpqcommand);
1483 SAFE_FREE(lprmcommand);
1484 DEBUG(0,("print_queue_receive: Got invalid print queue update message\n"));
1488 print_queue_update_with_lock(server_event_context(), msg, sharename,
1489 get_printer_fns_from_type((enum printing_types)printing_type),
1490 lpqcommand, lprmcommand );
1492 SAFE_FREE(lpqcommand);
1493 SAFE_FREE(lprmcommand);
1497 static void printing_pause_fd_handler(struct tevent_context *ev,
1498 struct tevent_fd *fde,
1503 * If pause_pipe[1] is closed it means the parent smbd
1504 * and children exited or aborted.
1506 exit_server_cleanly(NULL);
1509 extern struct child_pid *children;
1510 extern int num_children;
1512 static void add_child_pid(pid_t pid)
1514 struct child_pid *child;
1516 child = SMB_MALLOC_P(struct child_pid);
1517 if (child == NULL) {
1518 DEBUG(0, ("Could not add child struct -- malloc failed\n"));
1522 DLIST_ADD(children, child);
1526 static pid_t background_lpq_updater_pid = -1;
1528 /****************************************************************************
1529 main thread of the background lpq updater
1530 ****************************************************************************/
1531 void start_background_queue(struct tevent_context *ev,
1532 struct messaging_context *msg_ctx)
1534 /* Use local variables for this as we don't
1535 * need to save the parent side of this, just
1536 * ensure it closes when the process exits.
1540 DEBUG(3,("start_background_queue: Starting background LPQ thread\n"));
1542 if (pipe(pause_pipe) == -1) {
1543 DEBUG(5,("start_background_queue: cannot create pipe. %s\n", strerror(errno) ));
1547 background_lpq_updater_pid = sys_fork();
1549 if (background_lpq_updater_pid == -1) {
1550 DEBUG(5,("start_background_queue: background LPQ thread failed to start. %s\n", strerror(errno) ));
1554 /* Track the printing pid along with other smbd children */
1555 add_child_pid(background_lpq_updater_pid);
1557 if(background_lpq_updater_pid == 0) {
1558 struct tevent_fd *fde;
1563 DEBUG(5,("start_background_queue: background LPQ thread started\n"));
1565 close(pause_pipe[0]);
1568 status = reinit_after_fork(msg_ctx, ev, procid_self(), true);
1570 if (!NT_STATUS_IS_OK(status)) {
1571 DEBUG(0,("reinit_after_fork() failed\n"));
1572 smb_panic("reinit_after_fork() failed");
1575 smbd_setup_sig_term_handler();
1576 smbd_setup_sig_hup_handler(ev, msg_ctx);
1578 if (!serverid_register(procid_self(),
1579 FLAG_MSG_GENERAL|FLAG_MSG_SMBD
1580 |FLAG_MSG_PRINT_GENERAL)) {
1584 if (!locking_init()) {
1588 messaging_register(msg_ctx, NULL, MSG_PRINTER_UPDATE,
1589 print_queue_receive);
1591 fde = tevent_add_fd(ev, ev, pause_pipe[1], TEVENT_FD_READ,
1592 printing_pause_fd_handler,
1595 DEBUG(0,("tevent_add_fd() failed for pause_pipe\n"));
1596 smb_panic("tevent_add_fd() failed for pause_pipe");
1599 DEBUG(5,("start_background_queue: background LPQ thread waiting for messages\n"));
1600 ret = tevent_loop_wait(ev);
1601 /* should not be reached */
1602 DEBUG(0,("background_queue: tevent_loop_wait() exited with %d - %s\n",
1603 ret, (ret == 0) ? "out of events" : strerror(errno)));
1607 close(pause_pipe[1]);
1610 /****************************************************************************
1611 update the internal database from the system print queue for a queue
1612 ****************************************************************************/
1614 static void print_queue_update(struct messaging_context *msg_ctx,
1615 int snum, bool force)
1619 char *lpqcommand = NULL;
1620 char *lprmcommand = NULL;
1621 uint8 *buffer = NULL;
1624 struct tdb_print_db *pdb;
1626 struct printif *current_printif;
1627 TALLOC_CTX *ctx = talloc_tos();
1629 fstrcpy( sharename, lp_const_servicename(snum));
1631 /* don't strip out characters like '$' from the printername */
1633 lpqcommand = talloc_string_sub2(ctx,
1634 lp_lpqcommand(snum),
1636 lp_printername(snum),
1637 false, false, false);
1641 lpqcommand = talloc_sub_advanced(ctx,
1642 lp_servicename(snum),
1643 current_user_info.unix_name,
1645 current_user.ut.gid,
1646 get_current_username(),
1647 current_user_info.domain,
1653 lprmcommand = talloc_string_sub2(ctx,
1654 lp_lprmcommand(snum),
1656 lp_printername(snum),
1657 false, false, false);
1661 lprmcommand = talloc_sub_advanced(ctx,
1662 lp_servicename(snum),
1663 current_user_info.unix_name,
1665 current_user.ut.gid,
1666 get_current_username(),
1667 current_user_info.domain,
1674 * Make sure that the background queue process exists.
1675 * Otherwise just do the update ourselves
1678 if ( force || background_lpq_updater_pid == -1 ) {
1679 DEBUG(4,("print_queue_update: updating queue [%s] myself\n", sharename));
1680 current_printif = get_printer_fns( snum );
1681 print_queue_update_with_lock(server_event_context(), msg_ctx,
1682 sharename, current_printif,
1683 lpqcommand, lprmcommand);
1688 type = lp_printing(snum);
1690 /* get the length */
1692 len = tdb_pack( NULL, 0, "fdPP",
1698 buffer = SMB_XMALLOC_ARRAY( uint8, len );
1700 /* now pack the buffer */
1701 newlen = tdb_pack( buffer, len, "fdPP",
1707 SMB_ASSERT( newlen == len );
1709 DEBUG(10,("print_queue_update: Sending message -> printer = %s, "
1710 "type = %d, lpq command = [%s] lprm command = [%s]\n",
1711 sharename, type, lpqcommand, lprmcommand ));
1713 /* here we set a msg pending record for other smbd processes
1714 to throttle the number of duplicate print_queue_update msgs
1717 pdb = get_print_db_byname(sharename);
1723 snprintf(key, sizeof(key), "MSG_PENDING/%s", sharename);
1725 if ( !tdb_store_uint32( pdb->tdb, key, time(NULL) ) ) {
1726 /* log a message but continue on */
1728 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1732 release_print_db( pdb );
1734 /* finally send the message */
1736 messaging_send_buf(msg_ctx, pid_to_procid(background_lpq_updater_pid),
1737 MSG_PRINTER_UPDATE, (uint8 *)buffer, len);
1739 SAFE_FREE( buffer );
1744 /****************************************************************************
1745 Create/Update an entry in the print tdb that will allow us to send notify
1746 updates only to interested smbd's.
1747 ****************************************************************************/
1749 bool print_notify_register_pid(int snum)
1752 struct tdb_print_db *pdb = NULL;
1753 TDB_CONTEXT *tdb = NULL;
1754 const char *printername;
1755 uint32 mypid = (uint32)sys_getpid();
1759 /* if (snum == -1), then the change notify request was
1760 on a print server handle and we need to register on
1765 int num_services = lp_numservices();
1768 for ( idx=0; idx<num_services; idx++ ) {
1769 if (lp_snum_ok(idx) && lp_print_ok(idx) )
1770 print_notify_register_pid(idx);
1775 else /* register for a specific printer */
1777 printername = lp_const_servicename(snum);
1778 pdb = get_print_db_byname(printername);
1784 if (tdb_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) == -1) {
1785 DEBUG(0,("print_notify_register_pid: Failed to lock printer %s\n",
1788 release_print_db(pdb);
1792 data = get_printer_notify_pid_list( tdb, printername, True );
1794 /* Add ourselves and increase the refcount. */
1796 for (i = 0; i < data.dsize; i += 8) {
1797 if (IVAL(data.dptr,i) == mypid) {
1798 uint32 new_refcount = IVAL(data.dptr, i+4) + 1;
1799 SIVAL(data.dptr, i+4, new_refcount);
1804 if (i == data.dsize) {
1805 /* We weren't in the list. Realloc. */
1806 data.dptr = (uint8 *)SMB_REALLOC(data.dptr, data.dsize + 8);
1808 DEBUG(0,("print_notify_register_pid: Relloc fail for printer %s\n",
1813 SIVAL(data.dptr,data.dsize - 8,mypid);
1814 SIVAL(data.dptr,data.dsize - 4,1); /* Refcount. */
1817 /* Store back the record. */
1818 if (tdb_store_bystring(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) == -1) {
1819 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1820 list for printer %s\n", printername));
1828 tdb_unlock_bystring(tdb, NOTIFY_PID_LIST_KEY);
1830 release_print_db(pdb);
1831 SAFE_FREE(data.dptr);
1835 /****************************************************************************
1836 Update an entry in the print tdb that will allow us to send notify
1837 updates only to interested smbd's.
1838 ****************************************************************************/
1840 bool print_notify_deregister_pid(int snum)
1843 struct tdb_print_db *pdb = NULL;
1844 TDB_CONTEXT *tdb = NULL;
1845 const char *printername;
1846 uint32 mypid = (uint32)sys_getpid();
1850 /* if ( snum == -1 ), we are deregister a print server handle
1851 which means to deregister on all print queues */
1855 int num_services = lp_numservices();
1858 for ( idx=0; idx<num_services; idx++ ) {
1859 if ( lp_snum_ok(idx) && lp_print_ok(idx) )
1860 print_notify_deregister_pid(idx);
1865 else /* deregister a specific printer */
1867 printername = lp_const_servicename(snum);
1868 pdb = get_print_db_byname(printername);
1874 if (tdb_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) == -1) {
1875 DEBUG(0,("print_notify_register_pid: Failed to lock \
1876 printer %s database\n", printername));
1878 release_print_db(pdb);
1882 data = get_printer_notify_pid_list( tdb, printername, True );
1884 /* Reduce refcount. Remove ourselves if zero. */
1886 for (i = 0; i < data.dsize; ) {
1887 if (IVAL(data.dptr,i) == mypid) {
1888 uint32 refcount = IVAL(data.dptr, i+4);
1892 if (refcount == 0) {
1893 if (data.dsize - i > 8)
1894 memmove( &data.dptr[i], &data.dptr[i+8], data.dsize - i - 8);
1898 SIVAL(data.dptr, i+4, refcount);
1904 if (data.dsize == 0)
1905 SAFE_FREE(data.dptr);
1907 /* Store back the record. */
1908 if (tdb_store_bystring(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) == -1) {
1909 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1910 list for printer %s\n", printername));
1918 tdb_unlock_bystring(tdb, NOTIFY_PID_LIST_KEY);
1920 release_print_db(pdb);
1921 SAFE_FREE(data.dptr);
1925 /****************************************************************************
1926 Check if a jobid is valid. It is valid if it exists in the database.
1927 ****************************************************************************/
1929 bool print_job_exists(const char* sharename, uint32 jobid)
1931 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1937 ret = tdb_exists(pdb->tdb, print_key(jobid, &tmp));
1938 release_print_db(pdb);
1942 /****************************************************************************
1943 Give the filename used for a jobid.
1944 Only valid for the process doing the spooling and when the job
1945 has not been spooled.
1946 ****************************************************************************/
1948 char *print_job_fname(const char* sharename, uint32 jobid)
1950 struct printjob *pjob = print_job_find(sharename, jobid);
1951 if (!pjob || pjob->spooled || pjob->pid != sys_getpid())
1953 return pjob->filename;
1957 /****************************************************************************
1958 Give the filename used for a jobid.
1959 Only valid for the process doing the spooling and when the job
1960 has not been spooled.
1961 ****************************************************************************/
1963 struct spoolss_DeviceMode *print_job_devmode(const char* sharename, uint32 jobid)
1965 struct printjob *pjob = print_job_find(sharename, jobid);
1970 return pjob->devmode;
1973 /****************************************************************************
1974 Set the name of a job. Only possible for owner.
1975 ****************************************************************************/
1977 bool print_job_set_name(const char *sharename, uint32 jobid, const char *name)
1979 struct printjob *pjob;
1981 pjob = print_job_find(sharename, jobid);
1982 if (!pjob || pjob->pid != sys_getpid())
1985 fstrcpy(pjob->jobname, name);
1986 return pjob_store(server_event_context(), server_messaging_context(),
1987 sharename, jobid, pjob);
1990 /****************************************************************************
1991 Get the name of a job. Only possible for owner.
1992 ****************************************************************************/
1994 bool print_job_get_name(TALLOC_CTX *mem_ctx, const char *sharename, uint32_t jobid, char **name)
1996 struct printjob *pjob;
1998 pjob = print_job_find(sharename, jobid);
1999 if (!pjob || pjob->pid != sys_getpid()) {
2003 *name = talloc_strdup(mem_ctx, pjob->jobname);
2012 /***************************************************************************
2013 Remove a jobid from the 'jobs changed' list.
2014 ***************************************************************************/
2016 static bool remove_from_jobs_changed(const char* sharename, uint32 jobid)
2018 struct tdb_print_db *pdb = get_print_db_byname(sharename);
2020 size_t job_count, i;
2022 bool gotlock = False;
2030 key = string_tdb_data("INFO/jobs_changed");
2032 if (tdb_chainlock_with_timeout(pdb->tdb, key, 5) == -1)
2037 data = tdb_fetch(pdb->tdb, key);
2039 if (data.dptr == NULL || data.dsize == 0 || (data.dsize % 4 != 0))
2042 job_count = data.dsize / 4;
2043 for (i = 0; i < job_count; i++) {
2046 ch_jobid = IVAL(data.dptr, i*4);
2047 if (ch_jobid == jobid) {
2048 if (i < job_count -1 )
2049 memmove(data.dptr + (i*4), data.dptr + (i*4) + 4, (job_count - i - 1)*4 );
2051 if (tdb_store(pdb->tdb, key, data, TDB_REPLACE) == -1)
2061 tdb_chainunlock(pdb->tdb, key);
2062 SAFE_FREE(data.dptr);
2063 release_print_db(pdb);
2065 DEBUG(10,("remove_from_jobs_changed: removed jobid %u\n", (unsigned int)jobid ));
2067 DEBUG(10,("remove_from_jobs_changed: Failed to remove jobid %u\n", (unsigned int)jobid ));
2071 /****************************************************************************
2072 Delete a print job - don't update queue.
2073 ****************************************************************************/
2075 static bool print_job_delete1(int snum, uint32 jobid)
2077 const char* sharename = lp_const_servicename(snum);
2078 struct printjob *pjob = print_job_find(sharename, jobid);
2080 struct printif *current_printif = get_printer_fns( snum );
2086 * If already deleting just return.
2089 if (pjob->status == LPQ_DELETING)
2092 /* Hrm - we need to be able to cope with deleting a job before it
2093 has reached the spooler. Just mark it as LPQ_DELETING and
2094 let the print_queue_update() code rmeove the record */
2097 if (pjob->sysjob == -1) {
2098 DEBUG(5, ("attempt to delete job %u not seen by lpr\n", (unsigned int)jobid));
2101 /* Set the tdb entry to be deleting. */
2103 pjob->status = LPQ_DELETING;
2104 pjob_store(server_event_context(), server_messaging_context(),
2105 sharename, jobid, pjob);
2107 if (pjob->spooled && pjob->sysjob != -1)
2109 result = (*(current_printif->job_delete))(
2110 lp_printername(snum),
2111 lp_lprmcommand(snum),
2114 /* Delete the tdb entry if the delete succeeded or the job hasn't
2118 struct tdb_print_db *pdb = get_print_db_byname(sharename);
2123 pjob_delete(server_event_context(),
2124 server_messaging_context(),
2126 /* Ensure we keep a rough count of the number of total jobs... */
2127 tdb_change_int32_atomic(pdb->tdb, "INFO/total_jobs", &njobs, -1);
2128 release_print_db(pdb);
2132 remove_from_jobs_changed( sharename, jobid );
2134 return (result == 0);
2137 /****************************************************************************
2138 Return true if the current user owns the print job.
2139 ****************************************************************************/
2141 static bool is_owner(struct auth_serversupplied_info *server_info,
2142 const char *servicename,
2145 struct printjob *pjob = print_job_find(servicename, jobid);
2147 if (!pjob || !server_info)
2150 return strequal(pjob->user, server_info->sanitized_username);
2153 /****************************************************************************
2155 ****************************************************************************/
2157 WERROR print_job_delete(struct auth_serversupplied_info *server_info,
2158 struct messaging_context *msg_ctx,
2159 int snum, uint32_t jobid)
2161 const char* sharename = lp_const_servicename(snum);
2162 struct printjob *pjob;
2166 owner = is_owner(server_info, lp_const_servicename(snum), jobid);
2168 /* Check access against security descriptor or whether the user
2172 !print_access_check(server_info, msg_ctx, snum,
2173 JOB_ACCESS_ADMINISTER)) {
2174 DEBUG(3, ("delete denied by security descriptor\n"));
2176 /* BEGIN_ADMIN_LOG */
2177 sys_adminlog( LOG_ERR,
2178 "Permission denied-- user not allowed to delete, \
2179 pause, or resume print job. User name: %s. Printer name: %s.",
2180 uidtoname(server_info->utok.uid),
2181 lp_printername(snum) );
2184 return WERR_ACCESS_DENIED;
2188 * get the spooled filename of the print job
2189 * if this works, then the file has not been spooled
2190 * to the underlying print system. Just delete the
2191 * spool file & return.
2194 fname = print_job_fname(sharename, jobid);
2195 if (fname != NULL) {
2196 /* remove the spool file */
2197 DEBUG(10, ("print_job_delete: "
2198 "Removing spool file [%s]\n", fname));
2199 if (unlink(fname) == -1) {
2200 return map_werror_from_unix(errno);
2204 if (!print_job_delete1(snum, jobid)) {
2205 return WERR_ACCESS_DENIED;
2208 /* force update the database and say the delete failed if the
2211 print_queue_update(msg_ctx, snum, True);
2213 pjob = print_job_find(sharename, jobid);
2214 if (pjob && (pjob->status != LPQ_DELETING)) {
2215 return WERR_ACCESS_DENIED;
2218 return WERR_PRINTER_HAS_JOBS_QUEUED;
2221 /****************************************************************************
2223 ****************************************************************************/
2225 bool print_job_pause(struct auth_serversupplied_info *server_info,
2226 struct messaging_context *msg_ctx,
2227 int snum, uint32 jobid, WERROR *errcode)
2229 const char* sharename = lp_const_servicename(snum);
2230 struct printjob *pjob;
2232 struct printif *current_printif = get_printer_fns( snum );
2234 pjob = print_job_find(sharename, jobid);
2236 if (!pjob || !server_info) {
2237 DEBUG(10, ("print_job_pause: no pjob or user for jobid %u\n",
2238 (unsigned int)jobid ));
2242 if (!pjob->spooled || pjob->sysjob == -1) {
2243 DEBUG(10, ("print_job_pause: not spooled or bad sysjob = %d for jobid %u\n",
2244 (int)pjob->sysjob, (unsigned int)jobid ));
2248 if (!is_owner(server_info, lp_const_servicename(snum), jobid) &&
2249 !print_access_check(server_info, msg_ctx, snum,
2250 JOB_ACCESS_ADMINISTER)) {
2251 DEBUG(3, ("pause denied by security descriptor\n"));
2253 /* BEGIN_ADMIN_LOG */
2254 sys_adminlog( LOG_ERR,
2255 "Permission denied-- user not allowed to delete, \
2256 pause, or resume print job. User name: %s. Printer name: %s.",
2257 uidtoname(server_info->utok.uid),
2258 lp_printername(snum) );
2261 *errcode = WERR_ACCESS_DENIED;
2265 /* need to pause the spooled entry */
2266 ret = (*(current_printif->job_pause))(snum, pjob);
2269 *errcode = WERR_INVALID_PARAM;
2273 /* force update the database */
2274 print_cache_flush(lp_const_servicename(snum));
2276 /* Send a printer notify message */
2278 notify_job_status(server_event_context(), msg_ctx, sharename, jobid,
2281 /* how do we tell if this succeeded? */
2286 /****************************************************************************
2288 ****************************************************************************/
2290 bool print_job_resume(struct auth_serversupplied_info *server_info,
2291 struct messaging_context *msg_ctx,
2292 int snum, uint32 jobid, WERROR *errcode)
2294 const char *sharename = lp_const_servicename(snum);
2295 struct printjob *pjob;
2297 struct printif *current_printif = get_printer_fns( snum );
2299 pjob = print_job_find(sharename, jobid);
2301 if (!pjob || !server_info) {
2302 DEBUG(10, ("print_job_resume: no pjob or user for jobid %u\n",
2303 (unsigned int)jobid ));
2307 if (!pjob->spooled || pjob->sysjob == -1) {
2308 DEBUG(10, ("print_job_resume: not spooled or bad sysjob = %d for jobid %u\n",
2309 (int)pjob->sysjob, (unsigned int)jobid ));
2313 if (!is_owner(server_info, lp_const_servicename(snum), jobid) &&
2314 !print_access_check(server_info, msg_ctx, snum,
2315 JOB_ACCESS_ADMINISTER)) {
2316 DEBUG(3, ("resume denied by security descriptor\n"));
2317 *errcode = WERR_ACCESS_DENIED;
2319 /* BEGIN_ADMIN_LOG */
2320 sys_adminlog( LOG_ERR,
2321 "Permission denied-- user not allowed to delete, \
2322 pause, or resume print job. User name: %s. Printer name: %s.",
2323 uidtoname(server_info->utok.uid),
2324 lp_printername(snum) );
2329 ret = (*(current_printif->job_resume))(snum, pjob);
2332 *errcode = WERR_INVALID_PARAM;
2336 /* force update the database */
2337 print_cache_flush(lp_const_servicename(snum));
2339 /* Send a printer notify message */
2341 notify_job_status(server_event_context(), msg_ctx, sharename, jobid,
2347 /****************************************************************************
2348 Write to a print file.
2349 ****************************************************************************/
2351 ssize_t print_job_write(int snum, uint32 jobid, const char *buf, SMB_OFF_T pos, size_t size)
2353 const char* sharename = lp_const_servicename(snum);
2354 ssize_t return_code;
2355 struct printjob *pjob;
2357 pjob = print_job_find(sharename, jobid);
2361 /* don't allow another process to get this info - it is meaningless */
2362 if (pjob->pid != sys_getpid())
2365 /* if SMBD is spooling this can't be allowed */
2366 if (pjob->status == PJOB_SMBD_SPOOLING) {
2370 return_code = write_data_at_offset(pjob->fd, buf, size, pos);
2372 if (return_code>0) {
2374 pjob_store(server_event_context(), server_messaging_context(),
2375 sharename, jobid, pjob);
2380 /****************************************************************************
2381 Get the queue status - do not update if db is out of date.
2382 ****************************************************************************/
2384 static int get_queue_status(const char* sharename, print_status_struct *status)
2388 struct tdb_print_db *pdb = get_print_db_byname(sharename);
2392 ZERO_STRUCTP(status);
2399 fstr_sprintf(keystr, "STATUS/%s", sharename);
2400 data = tdb_fetch(pdb->tdb, string_tdb_data(keystr));
2402 if (data.dsize == sizeof(print_status_struct))
2403 /* this memcpy is ok since the status struct was
2404 not packed before storing it in the tdb */
2405 memcpy(status, data.dptr, sizeof(print_status_struct));
2406 SAFE_FREE(data.dptr);
2409 len = tdb_fetch_int32(pdb->tdb, "INFO/total_jobs");
2410 release_print_db(pdb);
2411 return (len == -1 ? 0 : len);
2414 /****************************************************************************
2415 Determine the number of jobs in a queue.
2416 ****************************************************************************/
2418 int print_queue_length(struct messaging_context *msg_ctx, int snum,
2419 print_status_struct *pstatus)
2421 const char* sharename = lp_const_servicename( snum );
2422 print_status_struct status;
2425 ZERO_STRUCT( status );
2427 /* make sure the database is up to date */
2428 if (print_cache_expired(lp_const_servicename(snum), True))
2429 print_queue_update(msg_ctx, snum, False);
2431 /* also fetch the queue status */
2432 memset(&status, 0, sizeof(status));
2433 len = get_queue_status(sharename, &status);
2441 /***************************************************************************
2442 Allocate a jobid. Hold the lock for as short a time as possible.
2443 ***************************************************************************/
2445 static WERROR allocate_print_jobid(struct tdb_print_db *pdb, int snum,
2446 const char *sharename, uint32 *pjobid)
2450 enum TDB_ERROR terr;
2453 *pjobid = (uint32)-1;
2455 for (i = 0; i < 3; i++) {
2456 /* Lock the database - only wait 20 seconds. */
2457 ret = tdb_lock_bystring_with_timeout(pdb->tdb,
2458 "INFO/nextjob", 20);
2460 DEBUG(0, ("allocate_print_jobid: "
2461 "Failed to lock printing database %s\n",
2463 terr = tdb_error(pdb->tdb);
2464 return ntstatus_to_werror(map_nt_error_from_tdb(terr));
2467 if (!tdb_fetch_uint32(pdb->tdb, "INFO/nextjob", &jobid)) {
2468 terr = tdb_error(pdb->tdb);
2469 if (terr != TDB_ERR_NOEXIST) {
2470 DEBUG(0, ("allocate_print_jobid: "
2471 "Failed to fetch INFO/nextjob "
2472 "for print queue %s\n", sharename));
2473 tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
2474 return ntstatus_to_werror(map_nt_error_from_tdb(terr));
2476 DEBUG(10, ("allocate_print_jobid: "
2477 "No existing jobid in %s\n", sharename));
2481 DEBUG(10, ("allocate_print_jobid: "
2482 "Read jobid %u from %s\n", jobid, sharename));
2484 jobid = NEXT_JOBID(jobid);
2486 ret = tdb_store_int32(pdb->tdb, "INFO/nextjob", jobid);
2488 terr = tdb_error(pdb->tdb);
2489 DEBUG(3, ("allocate_print_jobid: "
2490 "Failed to store INFO/nextjob.\n"));
2491 tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
2492 return ntstatus_to_werror(map_nt_error_from_tdb(terr));
2495 /* We've finished with the INFO/nextjob lock. */
2496 tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
2498 if (!print_job_exists(sharename, jobid)) {
2501 DEBUG(10, ("allocate_print_jobid: "
2502 "Found jobid %u in %s\n", jobid, sharename));
2506 DEBUG(0, ("allocate_print_jobid: "
2507 "Failed to allocate a print job for queue %s\n",
2509 /* Probably full... */
2510 return WERR_NO_SPOOL_SPACE;
2513 /* Store a dummy placeholder. */
2519 if (tdb_store(pdb->tdb, print_key(jobid, &tmp), dum,
2520 TDB_INSERT) == -1) {
2521 DEBUG(3, ("allocate_print_jobid: "
2522 "jobid (%d) failed to store placeholder.\n",
2524 terr = tdb_error(pdb->tdb);
2525 return ntstatus_to_werror(map_nt_error_from_tdb(terr));
2533 /***************************************************************************
2534 Append a jobid to the 'jobs changed' list.
2535 ***************************************************************************/
2537 static bool add_to_jobs_changed(struct tdb_print_db *pdb, uint32 jobid)
2542 SIVAL(&store_jobid, 0, jobid);
2543 data.dptr = (uint8 *)&store_jobid;
2546 DEBUG(10,("add_to_jobs_changed: Added jobid %u\n", (unsigned int)jobid ));
2548 return (tdb_append(pdb->tdb, string_tdb_data("INFO/jobs_changed"),
2553 /***************************************************************************
2554 Do all checks needed to determine if we can start a job.
2555 ***************************************************************************/
2557 static WERROR print_job_checks(struct auth_serversupplied_info *server_info,
2558 struct messaging_context *msg_ctx,
2559 int snum, int *njobs)
2561 const char *sharename = lp_const_servicename(snum);
2562 uint64_t dspace, dsize;
2566 if (!print_access_check(server_info, msg_ctx, snum,
2567 PRINTER_ACCESS_USE)) {
2568 DEBUG(3, ("print_job_checks: "
2569 "job start denied by security descriptor\n"));
2570 return WERR_ACCESS_DENIED;
2573 if (!print_time_access_check(server_info, msg_ctx, sharename)) {
2574 DEBUG(3, ("print_job_checks: "
2575 "job start denied by time check\n"));
2576 return WERR_ACCESS_DENIED;
2579 /* see if we have sufficient disk space */
2580 if (lp_minprintspace(snum)) {
2581 minspace = lp_minprintspace(snum);
2582 ret = sys_fsusage(lp_pathname(snum), &dspace, &dsize);
2583 if (ret == 0 && dspace < 2*minspace) {
2584 DEBUG(3, ("print_job_checks: "
2585 "disk space check failed.\n"));
2586 return WERR_NO_SPOOL_SPACE;
2590 /* for autoloaded printers, check that the printcap entry still exists */
2591 if (lp_autoloaded(snum) && !pcap_printername_ok(sharename)) {
2592 DEBUG(3, ("print_job_checks: printer name %s check failed.\n",
2594 return WERR_ACCESS_DENIED;
2597 /* Insure the maximum queue size is not violated */
2598 *njobs = print_queue_length(msg_ctx, snum, NULL);
2599 if (*njobs > lp_maxprintjobs(snum)) {
2600 DEBUG(3, ("print_job_checks: Queue %s number of jobs (%d) "
2601 "larger than max printjobs per queue (%d).\n",
2602 sharename, *njobs, lp_maxprintjobs(snum)));
2603 return WERR_NO_SPOOL_SPACE;
2609 /***************************************************************************
2611 ***************************************************************************/
2613 static WERROR print_job_spool_file(int snum, uint32_t jobid,
2614 const char *output_file,
2615 struct printjob *pjob)
2622 /* if this file is within the printer path, it means that smbd
2623 * is spooling it and will pass us control when it is finished.
2624 * Verify that the file name is ok, within path, and it is
2625 * already already there */
2627 path = lp_pathname(snum);
2629 if (strncmp(output_file, path, len) == 0 &&
2630 (output_file[len - 1] == '/' || output_file[len] == '/')) {
2632 /* verify path is not too long */
2633 if (strlen(output_file) >= sizeof(pjob->filename)) {
2634 return WERR_INVALID_NAME;
2637 /* verify that the file exists */
2638 if (sys_stat(output_file, &st, false) != 0) {
2639 return WERR_INVALID_NAME;
2642 fstrcpy(pjob->filename, output_file);
2644 DEBUG(3, ("print_job_spool_file:"
2645 "External spooling activated"));
2647 /* we do not open the file until spooling is done */
2649 pjob->status = PJOB_SMBD_SPOOLING;
2655 slprintf(pjob->filename, sizeof(pjob->filename)-1,
2656 "%s/%s%.8u.XXXXXX", lp_pathname(snum),
2657 PRINT_SPOOL_PREFIX, (unsigned int)jobid);
2658 pjob->fd = mkstemp(pjob->filename);
2660 if (pjob->fd == -1) {
2661 werr = map_werror_from_unix(errno);
2662 if (W_ERROR_EQUAL(werr, WERR_ACCESS_DENIED)) {
2663 /* Common setup error, force a report. */
2664 DEBUG(0, ("print_job_spool_file: "
2665 "insufficient permissions to open spool "
2666 "file %s.\n", pjob->filename));
2668 /* Normal case, report at level 3 and above. */
2669 DEBUG(3, ("print_job_spool_file: "
2670 "can't open spool file %s\n",
2679 /***************************************************************************
2680 Start spooling a job - return the jobid.
2681 ***************************************************************************/
2683 WERROR print_job_start(struct auth_serversupplied_info *server_info,
2684 struct messaging_context *msg_ctx,
2685 int snum, const char *docname, const char *filename,
2686 struct spoolss_DeviceMode *devmode, uint32_t *_jobid)
2690 struct printjob pjob;
2691 const char *sharename = lp_const_servicename(snum);
2692 struct tdb_print_db *pdb = get_print_db_byname(sharename);
2697 return WERR_INTERNAL_DB_CORRUPTION;
2700 path = lp_pathname(snum);
2702 werr = print_job_checks(server_info, msg_ctx, snum, &njobs);
2703 if (!W_ERROR_IS_OK(werr)) {
2704 release_print_db(pdb);
2708 DEBUG(10, ("print_job_start: "
2709 "Queue %s number of jobs (%d), max printjobs = %d\n",
2710 sharename, njobs, lp_maxprintjobs(snum)));
2712 werr = allocate_print_jobid(pdb, snum, sharename, &jobid);
2713 if (!W_ERROR_IS_OK(werr)) {
2717 /* create the database entry */
2721 pjob.pid = sys_getpid();
2724 pjob.starttime = time(NULL);
2725 pjob.status = LPQ_SPOOLING;
2727 pjob.spooled = False;
2729 pjob.devmode = devmode;
2731 fstrcpy(pjob.jobname, docname);
2733 fstrcpy(pjob.user, lp_printjob_username(snum));
2734 standard_sub_advanced(sharename, server_info->sanitized_username,
2735 path, server_info->utok.gid,
2736 server_info->sanitized_username,
2737 server_info->info3->base.domain.string,
2738 pjob.user, sizeof(pjob.user)-1);
2739 /* ensure NULL termination */
2740 pjob.user[sizeof(pjob.user)-1] = '\0';
2742 fstrcpy(pjob.queuename, lp_const_servicename(snum));
2744 /* we have a job entry - now create the spool file */
2745 werr = print_job_spool_file(snum, jobid, filename, &pjob);
2746 if (!W_ERROR_IS_OK(werr)) {
2750 pjob_store(server_event_context(), msg_ctx, sharename, jobid, &pjob);
2752 /* Update the 'jobs changed' entry used by print_queue_status. */
2753 add_to_jobs_changed(pdb, jobid);
2755 /* Ensure we keep a rough count of the number of total jobs... */
2756 tdb_change_int32_atomic(pdb->tdb, "INFO/total_jobs", &njobs, 1);
2758 release_print_db(pdb);
2765 pjob_delete(server_event_context(), msg_ctx, sharename, jobid);
2768 release_print_db(pdb);
2770 DEBUG(3, ("print_job_start: returning fail. "
2771 "Error = %s\n", win_errstr(werr)));
2775 /****************************************************************************
2776 Update the number of pages spooled to jobid
2777 ****************************************************************************/
2779 void print_job_endpage(int snum, uint32 jobid)
2781 const char* sharename = lp_const_servicename(snum);
2782 struct printjob *pjob;
2784 pjob = print_job_find(sharename, jobid);
2787 /* don't allow another process to get this info - it is meaningless */
2788 if (pjob->pid != sys_getpid())
2792 pjob_store(server_event_context(), server_messaging_context(),
2793 sharename, jobid, pjob);
2796 /****************************************************************************
2797 Print a file - called on closing the file. This spools the job.
2798 If normal close is false then we're tearing down the jobs - treat as an
2800 ****************************************************************************/
2802 NTSTATUS print_job_end(struct messaging_context *msg_ctx, int snum,
2803 uint32 jobid, enum file_close_type close_type)
2805 const char* sharename = lp_const_servicename(snum);
2806 struct printjob *pjob;
2808 SMB_STRUCT_STAT sbuf;
2809 struct printif *current_printif = get_printer_fns( snum );
2810 NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
2812 pjob = print_job_find(sharename, jobid);
2815 return NT_STATUS_PRINT_CANCELLED;
2818 if (pjob->spooled || pjob->pid != sys_getpid()) {
2819 return NT_STATUS_ACCESS_DENIED;
2822 if (close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) {
2823 if (pjob->status == PJOB_SMBD_SPOOLING) {
2824 /* take over the file now, smbd is done */
2825 if (sys_stat(pjob->filename, &sbuf, false) != 0) {
2826 status = map_nt_error_from_unix(errno);
2827 DEBUG(3, ("print_job_end: "
2828 "stat file failed for jobid %d\n",
2833 pjob->status = LPQ_SPOOLING;
2837 if ((sys_fstat(pjob->fd, &sbuf, false) != 0)) {
2838 status = map_nt_error_from_unix(errno);
2840 DEBUG(3, ("print_job_end: "
2841 "stat file failed for jobid %d\n",
2849 pjob->size = sbuf.st_ex_size;
2853 * Not a normal close, something has gone wrong. Cleanup.
2855 if (pjob->fd != -1) {
2861 /* Technically, this is not quite right. If the printer has a separator
2862 * page turned on, the NT spooler prints the separator page even if the
2863 * print job is 0 bytes. 010215 JRR */
2864 if (pjob->size == 0 || pjob->status == LPQ_DELETING) {
2865 /* don't bother spooling empty files or something being deleted. */
2866 DEBUG(5,("print_job_end: canceling spool of %s (%s)\n",
2867 pjob->filename, pjob->size ? "deleted" : "zero length" ));
2868 unlink(pjob->filename);
2869 pjob_delete(server_event_context(), msg_ctx, sharename, jobid);
2870 return NT_STATUS_OK;
2873 ret = (*(current_printif->job_submit))(snum, pjob);
2876 status = NT_STATUS_PRINT_CANCELLED;
2880 /* The print job has been successfully handed over to the back-end */
2882 pjob->spooled = True;
2883 pjob->status = LPQ_QUEUED;
2884 pjob_store(server_event_context(), msg_ctx, sharename, jobid, pjob);
2886 /* make sure the database is up to date */
2887 if (print_cache_expired(lp_const_servicename(snum), True))
2888 print_queue_update(msg_ctx, snum, False);
2890 return NT_STATUS_OK;
2894 /* The print job was not successfully started. Cleanup */
2895 /* Still need to add proper error return propagation! 010122:JRR */
2897 unlink(pjob->filename);
2898 pjob_delete(server_event_context(), msg_ctx, sharename, jobid);
2902 /****************************************************************************
2903 Get a snapshot of jobs in the system without traversing.
2904 ****************************************************************************/
2906 static bool get_stored_queue_info(struct messaging_context *msg_ctx,
2907 struct tdb_print_db *pdb, int snum,
2908 int *pcount, print_queue_struct **ppqueue)
2910 TDB_DATA data, cgdata;
2911 print_queue_struct *queue = NULL;
2913 uint32 extra_count = 0;
2914 int total_count = 0;
2917 int max_reported_jobs = lp_max_reported_jobs(snum);
2919 const char* sharename = lp_servicename(snum);
2921 /* make sure the database is up to date */
2922 if (print_cache_expired(lp_const_servicename(snum), True))
2923 print_queue_update(msg_ctx, snum, False);
2929 ZERO_STRUCT(cgdata);
2931 /* Get the stored queue data. */
2932 data = tdb_fetch(pdb->tdb, string_tdb_data("INFO/linear_queue_array"));
2934 if (data.dptr && data.dsize >= sizeof(qcount))
2935 len += tdb_unpack(data.dptr + len, data.dsize - len, "d", &qcount);
2937 /* Get the changed jobs list. */
2938 cgdata = tdb_fetch(pdb->tdb, string_tdb_data("INFO/jobs_changed"));
2939 if (cgdata.dptr != NULL && (cgdata.dsize % 4 == 0))
2940 extra_count = cgdata.dsize/4;
2942 DEBUG(5,("get_stored_queue_info: qcount = %u, extra_count = %u\n", (unsigned int)qcount, (unsigned int)extra_count));
2944 /* Allocate the queue size. */
2945 if (qcount == 0 && extra_count == 0)
2948 if ((queue = SMB_MALLOC_ARRAY(print_queue_struct, qcount + extra_count)) == NULL)
2951 /* Retrieve the linearised queue data. */
2953 for( i = 0; i < qcount; i++) {
2954 uint32 qjob, qsize, qpage_count, qstatus, qpriority, qtime;
2955 len += tdb_unpack(data.dptr + len, data.dsize - len, "ddddddff",
2964 queue[i].job = qjob;
2965 queue[i].size = qsize;
2966 queue[i].page_count = qpage_count;
2967 queue[i].status = qstatus;
2968 queue[i].priority = qpriority;
2969 queue[i].time = qtime;
2972 total_count = qcount;
2974 /* Add in the changed jobids. */
2975 for( i = 0; i < extra_count; i++) {
2977 struct printjob *pjob;
2979 jobid = IVAL(cgdata.dptr, i*4);
2980 DEBUG(5,("get_stored_queue_info: changed job = %u\n", (unsigned int)jobid));
2981 pjob = print_job_find(lp_const_servicename(snum), jobid);
2983 DEBUG(5,("get_stored_queue_info: failed to find changed job = %u\n", (unsigned int)jobid));
2984 remove_from_jobs_changed(sharename, jobid);
2988 queue[total_count].job = jobid;
2989 queue[total_count].size = pjob->size;
2990 queue[total_count].page_count = pjob->page_count;
2991 queue[total_count].status = pjob->status;
2992 queue[total_count].priority = 1;
2993 queue[total_count].time = pjob->starttime;
2994 fstrcpy(queue[total_count].fs_user, pjob->user);
2995 fstrcpy(queue[total_count].fs_file, pjob->jobname);
2999 /* Sort the queue by submission time otherwise they are displayed
3002 TYPESAFE_QSORT(queue, total_count, printjob_comp);
3004 DEBUG(5,("get_stored_queue_info: total_count = %u\n", (unsigned int)total_count));
3006 if (max_reported_jobs && total_count > max_reported_jobs)
3007 total_count = max_reported_jobs;
3010 *pcount = total_count;
3016 SAFE_FREE(data.dptr);
3017 SAFE_FREE(cgdata.dptr);
3021 /****************************************************************************
3022 Get a printer queue listing.
3023 set queue = NULL and status = NULL if you just want to update the cache
3024 ****************************************************************************/
3026 int print_queue_status(struct messaging_context *msg_ctx, int snum,
3027 print_queue_struct **ppqueue,
3028 print_status_struct *status)
3032 const char *sharename;
3033 struct tdb_print_db *pdb;
3036 /* make sure the database is up to date */
3038 if (print_cache_expired(lp_const_servicename(snum), True))
3039 print_queue_update(msg_ctx, snum, False);
3041 /* return if we are done */
3042 if ( !ppqueue || !status )
3046 sharename = lp_const_servicename(snum);
3047 pdb = get_print_db_byname(sharename);
3053 * Fetch the queue status. We must do this first, as there may
3054 * be no jobs in the queue.
3057 ZERO_STRUCTP(status);
3058 slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", sharename);
3059 key = string_tdb_data(keystr);
3061 data = tdb_fetch(pdb->tdb, key);
3063 if (data.dsize == sizeof(*status)) {
3064 /* this memcpy is ok since the status struct was
3065 not packed before storing it in the tdb */
3066 memcpy(status, data.dptr, sizeof(*status));
3068 SAFE_FREE(data.dptr);
3072 * Now, fetch the print queue information. We first count the number
3073 * of entries, and then only retrieve the queue if necessary.
3076 if (!get_stored_queue_info(msg_ctx, pdb, snum, &count, ppqueue)) {
3077 release_print_db(pdb);
3081 release_print_db(pdb);
3085 /****************************************************************************
3087 ****************************************************************************/
3089 WERROR print_queue_pause(struct auth_serversupplied_info *server_info,
3090 struct messaging_context *msg_ctx, int snum)
3093 struct printif *current_printif = get_printer_fns( snum );
3095 if (!print_access_check(server_info, msg_ctx, snum,
3096 PRINTER_ACCESS_ADMINISTER)) {
3097 return WERR_ACCESS_DENIED;
3103 ret = (*(current_printif->queue_pause))(snum);
3108 return WERR_INVALID_PARAM;
3111 /* force update the database */
3112 print_cache_flush(lp_const_servicename(snum));
3114 /* Send a printer notify message */
3116 notify_printer_status(server_event_context(), msg_ctx, snum,
3117 PRINTER_STATUS_PAUSED);
3122 /****************************************************************************
3124 ****************************************************************************/
3126 WERROR print_queue_resume(struct auth_serversupplied_info *server_info,
3127 struct messaging_context *msg_ctx, int snum)
3130 struct printif *current_printif = get_printer_fns( snum );
3132 if (!print_access_check(server_info, msg_ctx, snum,
3133 PRINTER_ACCESS_ADMINISTER)) {
3134 return WERR_ACCESS_DENIED;
3139 ret = (*(current_printif->queue_resume))(snum);
3144 return WERR_INVALID_PARAM;
3147 /* make sure the database is up to date */
3148 if (print_cache_expired(lp_const_servicename(snum), True))
3149 print_queue_update(msg_ctx, snum, True);
3151 /* Send a printer notify message */
3153 notify_printer_status(server_event_context(), msg_ctx, snum,
3159 /****************************************************************************
3160 Purge a queue - implemented by deleting all jobs that we can delete.
3161 ****************************************************************************/
3163 WERROR print_queue_purge(struct auth_serversupplied_info *server_info,
3164 struct messaging_context *msg_ctx, int snum)
3166 print_queue_struct *queue;
3167 print_status_struct status;
3171 /* Force and update so the count is accurate (i.e. not a cached count) */
3172 print_queue_update(msg_ctx, snum, True);
3174 can_job_admin = print_access_check(server_info,
3177 JOB_ACCESS_ADMINISTER);
3178 njobs = print_queue_status(msg_ctx, snum, &queue, &status);
3180 if ( can_job_admin )
3183 for (i=0;i<njobs;i++) {
3184 bool owner = is_owner(server_info, lp_const_servicename(snum),
3187 if (owner || can_job_admin) {
3188 print_job_delete1(snum, queue[i].job);
3192 if ( can_job_admin )
3195 /* update the cache */
3196 print_queue_update(msg_ctx, snum, True);