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(const char *sharename, print_queue_struct *q, uint32 jobid)
759 struct printjob pj, *old_pj;
761 if (jobid == (uint32)-1)
762 jobid = q->job + UNIX_JOB_START;
764 /* Preserve the timestamp on an existing unix print job */
766 old_pj = print_job_find(sharename, jobid);
773 pj.starttime = old_pj ? old_pj->starttime : q->time;
774 pj.status = q->status;
777 fstrcpy(pj.filename, old_pj ? old_pj->filename : "");
778 if (jobid < UNIX_JOB_START) {
780 fstrcpy(pj.jobname, old_pj ? old_pj->jobname : "Remote Downlevel Document");
783 fstrcpy(pj.jobname, old_pj ? old_pj->jobname : q->fs_file);
785 fstrcpy(pj.user, old_pj ? old_pj->user : q->fs_user);
786 fstrcpy(pj.queuename, old_pj ? old_pj->queuename : sharename );
788 pjob_store(server_event_context(), server_messaging_context(),
789 sharename, jobid, &pj);
793 struct traverse_struct {
794 print_queue_struct *queue;
795 int qcount, snum, maxcount, total_jobs;
796 const char *sharename;
798 const char *lprm_command;
799 struct printif *print_if;
802 /****************************************************************************
803 Utility fn to delete any jobs that are no longer active.
804 ****************************************************************************/
806 static int traverse_fn_delete(TDB_CONTEXT *t, TDB_DATA key, TDB_DATA data, void *state)
808 struct traverse_struct *ts = (struct traverse_struct *)state;
809 struct printjob pjob;
813 if ( key.dsize != sizeof(jobid) )
816 jobid = IVAL(key.dptr, 0);
817 if ( unpack_pjob( data.dptr, data.dsize, &pjob ) == -1 )
819 talloc_free(pjob.devmode);
823 /* remove a unix job if it isn't in the system queue any more */
825 for (i=0;i<ts->qcount;i++) {
826 uint32 u_jobid = (ts->queue[i].job + UNIX_JOB_START);
827 if (jobid == u_jobid)
830 if (i == ts->qcount) {
831 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !smbjob\n",
832 (unsigned int)jobid ));
833 pjob_delete(server_event_context(),
834 server_messaging_context(),
835 ts->sharename, jobid);
839 /* need to continue the the bottom of the function to
840 save the correct attributes */
843 /* maybe it hasn't been spooled yet */
845 /* if a job is not spooled and the process doesn't
846 exist then kill it. This cleans up after smbd
848 if (!process_exists_by_pid(pjob.pid)) {
849 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !process_exists (%u)\n",
850 (unsigned int)jobid, (unsigned int)pjob.pid ));
851 pjob_delete(server_event_context(),
852 server_messaging_context(),
853 ts->sharename, jobid);
859 /* this check only makes sense for jobs submitted from Windows clients */
862 for (i=0;i<ts->qcount;i++) {
865 if ( pjob.status == LPQ_DELETED )
868 curr_jobid = print_parse_jobid(ts->queue[i].fs_file);
870 if (jobid == curr_jobid) {
872 /* try to clean up any jobs that need to be deleted */
874 if ( pjob.status == LPQ_DELETING ) {
877 result = (*(ts->print_if->job_delete))(
878 ts->sharename, ts->lprm_command, &pjob );
881 /* if we can't delete, then reset the job status */
882 pjob.status = LPQ_QUEUED;
883 pjob_store(server_event_context(),
884 server_messaging_context(),
885 ts->sharename, jobid, &pjob);
888 /* if we deleted the job, the remove the tdb record */
889 pjob_delete(server_event_context(),
890 server_messaging_context(),
891 ts->sharename, jobid);
892 pjob.status = LPQ_DELETED;
902 /* The job isn't in the system queue - we have to assume it has
903 completed, so delete the database entry. */
905 if (i == ts->qcount) {
907 /* A race can occur between the time a job is spooled and
908 when it appears in the lpq output. This happens when
909 the job is added to printing.tdb when another smbd
910 running print_queue_update() has completed a lpq and
911 is currently traversing the printing tdb and deleting jobs.
912 Don't delete the job if it was submitted after the lpq_time. */
914 if (pjob.starttime < ts->lpq_time) {
915 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to pjob.starttime (%u) < ts->lpq_time (%u)\n",
917 (unsigned int)pjob.starttime,
918 (unsigned int)ts->lpq_time ));
919 pjob_delete(server_event_context(),
920 server_messaging_context(),
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( const char *sharename,
1217 struct printif *current_printif,
1218 char *lpq_command, char *lprm_command )
1221 print_queue_struct *queue = NULL;
1222 print_status_struct status;
1223 print_status_struct old_status;
1224 struct printjob *pjob;
1225 struct traverse_struct tstruct;
1228 fstring keystr, cachestr;
1229 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1235 DEBUG(5,("print_queue_update_internal: printer = %s, type = %d, lpq command = [%s]\n",
1236 sharename, current_printif->type, lpq_command));
1239 * Update the cache time FIRST ! Stops others even
1240 * attempting to get the lock and doing this
1241 * if the lpq takes a long time.
1244 slprintf(cachestr, sizeof(cachestr)-1, "CACHE/%s", sharename);
1245 tdb_store_int32(pdb->tdb, cachestr, (int)time(NULL));
1247 /* get the current queue using the appropriate interface */
1248 ZERO_STRUCT(status);
1250 qcount = (*(current_printif->queue_get))(sharename,
1251 current_printif->type,
1252 lpq_command, &queue, &status);
1254 DEBUG(3, ("print_queue_update_internal: %d job%s in queue for %s\n",
1255 qcount, (qcount != 1) ? "s" : "", sharename));
1257 /* Sort the queue by submission time otherwise they are displayed
1260 TYPESAFE_QSORT(queue, qcount, printjob_comp);
1263 any job in the internal database that is marked as spooled
1264 and doesn't exist in the system queue is considered finished
1265 and removed from the database
1267 any job in the system database but not in the internal database
1268 is added as a unix job
1270 fill in any system job numbers as we go
1273 jcdata = get_jobs_changed_data(pdb);
1275 for (i=0; i<qcount; i++) {
1276 uint32 jobid = print_parse_jobid(queue[i].fs_file);
1278 if (jobid == (uint32)-1) {
1279 /* assume its a unix print job */
1280 print_unix_job(sharename, &queue[i], jobid);
1284 /* we have an active SMB print job - update its status */
1285 pjob = print_job_find(sharename, jobid);
1287 /* err, somethings wrong. Probably smbd was restarted
1288 with jobs in the queue. All we can do is treat them
1289 like unix jobs. Pity. */
1290 print_unix_job(sharename, &queue[i], jobid);
1294 pjob->sysjob = queue[i].job;
1296 /* don't reset the status on jobs to be deleted */
1298 if ( pjob->status != LPQ_DELETING )
1299 pjob->status = queue[i].status;
1301 pjob_store(server_event_context(), server_messaging_context(),
1302 sharename, jobid, pjob);
1304 check_job_changed(sharename, jcdata, jobid);
1307 SAFE_FREE(jcdata.dptr);
1309 /* now delete any queued entries that don't appear in the
1311 tstruct.queue = queue;
1312 tstruct.qcount = qcount;
1314 tstruct.total_jobs = 0;
1315 tstruct.lpq_time = time(NULL);
1316 tstruct.sharename = sharename;
1317 tstruct.lprm_command = lprm_command;
1318 tstruct.print_if = current_printif;
1320 tdb_traverse(pdb->tdb, traverse_fn_delete, (void *)&tstruct);
1322 /* Store the linearised queue, max jobs only. */
1323 store_queue_struct(pdb, &tstruct);
1325 SAFE_FREE(tstruct.queue);
1327 DEBUG(10,("print_queue_update_internal: printer %s INFO/total_jobs = %d\n",
1328 sharename, tstruct.total_jobs ));
1330 tdb_store_int32(pdb->tdb, "INFO/total_jobs", tstruct.total_jobs);
1332 get_queue_status(sharename, &old_status);
1333 if (old_status.qcount != qcount)
1334 DEBUG(10,("print_queue_update_internal: queue status change %d jobs -> %d jobs for printer %s\n",
1335 old_status.qcount, qcount, sharename));
1337 /* store the new queue status structure */
1338 slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", sharename);
1339 key = string_tdb_data(keystr);
1341 status.qcount = qcount;
1342 data.dptr = (uint8 *)&status;
1343 data.dsize = sizeof(status);
1344 tdb_store(pdb->tdb, key, data, TDB_REPLACE);
1347 * Update the cache time again. We want to do this call
1348 * as little as possible...
1351 slprintf(keystr, sizeof(keystr)-1, "CACHE/%s", sharename);
1352 tdb_store_int32(pdb->tdb, keystr, (int32)time(NULL));
1354 /* clear the msg pending record for this queue */
1356 snprintf(keystr, sizeof(keystr), "MSG_PENDING/%s", sharename);
1358 if ( !tdb_store_uint32( pdb->tdb, keystr, 0 ) ) {
1359 /* log a message but continue on */
1361 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1365 release_print_db( pdb );
1370 /****************************************************************************
1371 Update the internal database from the system print queue for a queue.
1372 obtain a lock on the print queue before proceeding (needed when mutiple
1373 smbd processes maytry to update the lpq cache concurrently).
1374 ****************************************************************************/
1376 static void print_queue_update_with_lock( const char *sharename,
1377 struct printif *current_printif,
1378 char *lpq_command, char *lprm_command )
1381 struct tdb_print_db *pdb;
1383 DEBUG(5,("print_queue_update_with_lock: printer share = %s\n", sharename));
1384 pdb = get_print_db_byname(sharename);
1388 if ( !print_cache_expired(sharename, False) ) {
1389 DEBUG(5,("print_queue_update_with_lock: print cache for %s is still ok\n", sharename));
1390 release_print_db(pdb);
1395 * Check to see if someone else is doing this update.
1396 * This is essentially a mutex on the update.
1399 if (get_updating_pid(sharename) != -1) {
1400 release_print_db(pdb);
1404 /* Lock the queue for the database update */
1406 slprintf(keystr, sizeof(keystr) - 1, "LOCK/%s", sharename);
1407 /* Only wait 10 seconds for this. */
1408 if (tdb_lock_bystring_with_timeout(pdb->tdb, keystr, 10) == -1) {
1409 DEBUG(0,("print_queue_update_with_lock: Failed to lock printer %s database\n", sharename));
1410 release_print_db(pdb);
1415 * Ensure that no one else got in here.
1416 * If the updating pid is still -1 then we are
1420 if (get_updating_pid(sharename) != -1) {
1422 * Someone else is doing the update, exit.
1424 tdb_unlock_bystring(pdb->tdb, keystr);
1425 release_print_db(pdb);
1430 * We're going to do the update ourselves.
1433 /* Tell others we're doing the update. */
1434 set_updating_pid(sharename, True);
1437 * Allow others to enter and notice we're doing
1441 tdb_unlock_bystring(pdb->tdb, keystr);
1443 /* do the main work now */
1445 print_queue_update_internal( sharename, current_printif,
1446 lpq_command, lprm_command );
1448 /* Delete our pid from the db. */
1449 set_updating_pid(sharename, False);
1450 release_print_db(pdb);
1453 /****************************************************************************
1454 this is the receive function of the background lpq updater
1455 ****************************************************************************/
1456 static void print_queue_receive(struct messaging_context *msg,
1459 struct server_id server_id,
1463 char *lpqcommand = NULL, *lprmcommand = NULL;
1467 len = tdb_unpack( (uint8 *)data->data, data->length, "fdPP",
1474 SAFE_FREE(lpqcommand);
1475 SAFE_FREE(lprmcommand);
1476 DEBUG(0,("print_queue_receive: Got invalid print queue update message\n"));
1480 print_queue_update_with_lock(sharename,
1481 get_printer_fns_from_type((enum printing_types)printing_type),
1482 lpqcommand, lprmcommand );
1484 SAFE_FREE(lpqcommand);
1485 SAFE_FREE(lprmcommand);
1489 static void printing_pause_fd_handler(struct tevent_context *ev,
1490 struct tevent_fd *fde,
1495 * If pause_pipe[1] is closed it means the parent smbd
1496 * and children exited or aborted.
1498 exit_server_cleanly(NULL);
1501 extern struct child_pid *children;
1502 extern int num_children;
1504 static void add_child_pid(pid_t pid)
1506 struct child_pid *child;
1508 child = SMB_MALLOC_P(struct child_pid);
1509 if (child == NULL) {
1510 DEBUG(0, ("Could not add child struct -- malloc failed\n"));
1514 DLIST_ADD(children, child);
1518 static pid_t background_lpq_updater_pid = -1;
1520 /****************************************************************************
1521 main thread of the background lpq updater
1522 ****************************************************************************/
1523 void start_background_queue(struct tevent_context *ev,
1524 struct messaging_context *msg_ctx)
1526 /* Use local variables for this as we don't
1527 * need to save the parent side of this, just
1528 * ensure it closes when the process exits.
1532 DEBUG(3,("start_background_queue: Starting background LPQ thread\n"));
1534 if (pipe(pause_pipe) == -1) {
1535 DEBUG(5,("start_background_queue: cannot create pipe. %s\n", strerror(errno) ));
1539 background_lpq_updater_pid = sys_fork();
1541 if (background_lpq_updater_pid == -1) {
1542 DEBUG(5,("start_background_queue: background LPQ thread failed to start. %s\n", strerror(errno) ));
1546 /* Track the printing pid along with other smbd children */
1547 add_child_pid(background_lpq_updater_pid);
1549 if(background_lpq_updater_pid == 0) {
1550 struct tevent_fd *fde;
1555 DEBUG(5,("start_background_queue: background LPQ thread started\n"));
1557 close(pause_pipe[0]);
1560 status = reinit_after_fork(msg_ctx, ev, procid_self(), true);
1562 if (!NT_STATUS_IS_OK(status)) {
1563 DEBUG(0,("reinit_after_fork() failed\n"));
1564 smb_panic("reinit_after_fork() failed");
1567 smbd_setup_sig_term_handler();
1568 smbd_setup_sig_hup_handler(ev, msg_ctx);
1570 if (!serverid_register(procid_self(),
1571 FLAG_MSG_GENERAL|FLAG_MSG_SMBD
1572 |FLAG_MSG_PRINT_GENERAL)) {
1576 if (!locking_init()) {
1580 messaging_register(msg_ctx, NULL, MSG_PRINTER_UPDATE,
1581 print_queue_receive);
1583 fde = tevent_add_fd(ev, ev, pause_pipe[1], TEVENT_FD_READ,
1584 printing_pause_fd_handler,
1587 DEBUG(0,("tevent_add_fd() failed for pause_pipe\n"));
1588 smb_panic("tevent_add_fd() failed for pause_pipe");
1591 DEBUG(5,("start_background_queue: background LPQ thread waiting for messages\n"));
1592 ret = tevent_loop_wait(ev);
1593 /* should not be reached */
1594 DEBUG(0,("background_queue: tevent_loop_wait() exited with %d - %s\n",
1595 ret, (ret == 0) ? "out of events" : strerror(errno)));
1599 close(pause_pipe[1]);
1602 /****************************************************************************
1603 update the internal database from the system print queue for a queue
1604 ****************************************************************************/
1606 static void print_queue_update(struct messaging_context *msg_ctx,
1607 int snum, bool force)
1611 char *lpqcommand = NULL;
1612 char *lprmcommand = NULL;
1613 uint8 *buffer = NULL;
1616 struct tdb_print_db *pdb;
1618 struct printif *current_printif;
1619 TALLOC_CTX *ctx = talloc_tos();
1621 fstrcpy( sharename, lp_const_servicename(snum));
1623 /* don't strip out characters like '$' from the printername */
1625 lpqcommand = talloc_string_sub2(ctx,
1626 lp_lpqcommand(snum),
1628 lp_printername(snum),
1629 false, false, false);
1633 lpqcommand = talloc_sub_advanced(ctx,
1634 lp_servicename(snum),
1635 current_user_info.unix_name,
1637 current_user.ut.gid,
1638 get_current_username(),
1639 current_user_info.domain,
1645 lprmcommand = talloc_string_sub2(ctx,
1646 lp_lprmcommand(snum),
1648 lp_printername(snum),
1649 false, false, false);
1653 lprmcommand = talloc_sub_advanced(ctx,
1654 lp_servicename(snum),
1655 current_user_info.unix_name,
1657 current_user.ut.gid,
1658 get_current_username(),
1659 current_user_info.domain,
1666 * Make sure that the background queue process exists.
1667 * Otherwise just do the update ourselves
1670 if ( force || background_lpq_updater_pid == -1 ) {
1671 DEBUG(4,("print_queue_update: updating queue [%s] myself\n", sharename));
1672 current_printif = get_printer_fns( snum );
1673 print_queue_update_with_lock( sharename, current_printif, lpqcommand, lprmcommand );
1678 type = lp_printing(snum);
1680 /* get the length */
1682 len = tdb_pack( NULL, 0, "fdPP",
1688 buffer = SMB_XMALLOC_ARRAY( uint8, len );
1690 /* now pack the buffer */
1691 newlen = tdb_pack( buffer, len, "fdPP",
1697 SMB_ASSERT( newlen == len );
1699 DEBUG(10,("print_queue_update: Sending message -> printer = %s, "
1700 "type = %d, lpq command = [%s] lprm command = [%s]\n",
1701 sharename, type, lpqcommand, lprmcommand ));
1703 /* here we set a msg pending record for other smbd processes
1704 to throttle the number of duplicate print_queue_update msgs
1707 pdb = get_print_db_byname(sharename);
1713 snprintf(key, sizeof(key), "MSG_PENDING/%s", sharename);
1715 if ( !tdb_store_uint32( pdb->tdb, key, time(NULL) ) ) {
1716 /* log a message but continue on */
1718 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1722 release_print_db( pdb );
1724 /* finally send the message */
1726 messaging_send_buf(msg_ctx, pid_to_procid(background_lpq_updater_pid),
1727 MSG_PRINTER_UPDATE, (uint8 *)buffer, len);
1729 SAFE_FREE( buffer );
1734 /****************************************************************************
1735 Create/Update an entry in the print tdb that will allow us to send notify
1736 updates only to interested smbd's.
1737 ****************************************************************************/
1739 bool print_notify_register_pid(int snum)
1742 struct tdb_print_db *pdb = NULL;
1743 TDB_CONTEXT *tdb = NULL;
1744 const char *printername;
1745 uint32 mypid = (uint32)sys_getpid();
1749 /* if (snum == -1), then the change notify request was
1750 on a print server handle and we need to register on
1755 int num_services = lp_numservices();
1758 for ( idx=0; idx<num_services; idx++ ) {
1759 if (lp_snum_ok(idx) && lp_print_ok(idx) )
1760 print_notify_register_pid(idx);
1765 else /* register for a specific printer */
1767 printername = lp_const_servicename(snum);
1768 pdb = get_print_db_byname(printername);
1774 if (tdb_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) == -1) {
1775 DEBUG(0,("print_notify_register_pid: Failed to lock printer %s\n",
1778 release_print_db(pdb);
1782 data = get_printer_notify_pid_list( tdb, printername, True );
1784 /* Add ourselves and increase the refcount. */
1786 for (i = 0; i < data.dsize; i += 8) {
1787 if (IVAL(data.dptr,i) == mypid) {
1788 uint32 new_refcount = IVAL(data.dptr, i+4) + 1;
1789 SIVAL(data.dptr, i+4, new_refcount);
1794 if (i == data.dsize) {
1795 /* We weren't in the list. Realloc. */
1796 data.dptr = (uint8 *)SMB_REALLOC(data.dptr, data.dsize + 8);
1798 DEBUG(0,("print_notify_register_pid: Relloc fail for printer %s\n",
1803 SIVAL(data.dptr,data.dsize - 8,mypid);
1804 SIVAL(data.dptr,data.dsize - 4,1); /* Refcount. */
1807 /* Store back the record. */
1808 if (tdb_store_bystring(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) == -1) {
1809 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1810 list for printer %s\n", printername));
1818 tdb_unlock_bystring(tdb, NOTIFY_PID_LIST_KEY);
1820 release_print_db(pdb);
1821 SAFE_FREE(data.dptr);
1825 /****************************************************************************
1826 Update an entry in the print tdb that will allow us to send notify
1827 updates only to interested smbd's.
1828 ****************************************************************************/
1830 bool print_notify_deregister_pid(int snum)
1833 struct tdb_print_db *pdb = NULL;
1834 TDB_CONTEXT *tdb = NULL;
1835 const char *printername;
1836 uint32 mypid = (uint32)sys_getpid();
1840 /* if ( snum == -1 ), we are deregister a print server handle
1841 which means to deregister on all print queues */
1845 int num_services = lp_numservices();
1848 for ( idx=0; idx<num_services; idx++ ) {
1849 if ( lp_snum_ok(idx) && lp_print_ok(idx) )
1850 print_notify_deregister_pid(idx);
1855 else /* deregister a specific printer */
1857 printername = lp_const_servicename(snum);
1858 pdb = get_print_db_byname(printername);
1864 if (tdb_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) == -1) {
1865 DEBUG(0,("print_notify_register_pid: Failed to lock \
1866 printer %s database\n", printername));
1868 release_print_db(pdb);
1872 data = get_printer_notify_pid_list( tdb, printername, True );
1874 /* Reduce refcount. Remove ourselves if zero. */
1876 for (i = 0; i < data.dsize; ) {
1877 if (IVAL(data.dptr,i) == mypid) {
1878 uint32 refcount = IVAL(data.dptr, i+4);
1882 if (refcount == 0) {
1883 if (data.dsize - i > 8)
1884 memmove( &data.dptr[i], &data.dptr[i+8], data.dsize - i - 8);
1888 SIVAL(data.dptr, i+4, refcount);
1894 if (data.dsize == 0)
1895 SAFE_FREE(data.dptr);
1897 /* Store back the record. */
1898 if (tdb_store_bystring(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) == -1) {
1899 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1900 list for printer %s\n", printername));
1908 tdb_unlock_bystring(tdb, NOTIFY_PID_LIST_KEY);
1910 release_print_db(pdb);
1911 SAFE_FREE(data.dptr);
1915 /****************************************************************************
1916 Check if a jobid is valid. It is valid if it exists in the database.
1917 ****************************************************************************/
1919 bool print_job_exists(const char* sharename, uint32 jobid)
1921 struct tdb_print_db *pdb = get_print_db_byname(sharename);
1927 ret = tdb_exists(pdb->tdb, print_key(jobid, &tmp));
1928 release_print_db(pdb);
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 char *print_job_fname(const char* sharename, uint32 jobid)
1940 struct printjob *pjob = print_job_find(sharename, jobid);
1941 if (!pjob || pjob->spooled || pjob->pid != sys_getpid())
1943 return pjob->filename;
1947 /****************************************************************************
1948 Give the filename used for a jobid.
1949 Only valid for the process doing the spooling and when the job
1950 has not been spooled.
1951 ****************************************************************************/
1953 struct spoolss_DeviceMode *print_job_devmode(const char* sharename, uint32 jobid)
1955 struct printjob *pjob = print_job_find(sharename, jobid);
1960 return pjob->devmode;
1963 /****************************************************************************
1964 Set the name of a job. Only possible for owner.
1965 ****************************************************************************/
1967 bool print_job_set_name(const char *sharename, uint32 jobid, const char *name)
1969 struct printjob *pjob;
1971 pjob = print_job_find(sharename, jobid);
1972 if (!pjob || pjob->pid != sys_getpid())
1975 fstrcpy(pjob->jobname, name);
1976 return pjob_store(server_event_context(), server_messaging_context(),
1977 sharename, jobid, pjob);
1980 /****************************************************************************
1981 Get the name of a job. Only possible for owner.
1982 ****************************************************************************/
1984 bool print_job_get_name(TALLOC_CTX *mem_ctx, const char *sharename, uint32_t jobid, char **name)
1986 struct printjob *pjob;
1988 pjob = print_job_find(sharename, jobid);
1989 if (!pjob || pjob->pid != sys_getpid()) {
1993 *name = talloc_strdup(mem_ctx, pjob->jobname);
2002 /***************************************************************************
2003 Remove a jobid from the 'jobs changed' list.
2004 ***************************************************************************/
2006 static bool remove_from_jobs_changed(const char* sharename, uint32 jobid)
2008 struct tdb_print_db *pdb = get_print_db_byname(sharename);
2010 size_t job_count, i;
2012 bool gotlock = False;
2020 key = string_tdb_data("INFO/jobs_changed");
2022 if (tdb_chainlock_with_timeout(pdb->tdb, key, 5) == -1)
2027 data = tdb_fetch(pdb->tdb, key);
2029 if (data.dptr == NULL || data.dsize == 0 || (data.dsize % 4 != 0))
2032 job_count = data.dsize / 4;
2033 for (i = 0; i < job_count; i++) {
2036 ch_jobid = IVAL(data.dptr, i*4);
2037 if (ch_jobid == jobid) {
2038 if (i < job_count -1 )
2039 memmove(data.dptr + (i*4), data.dptr + (i*4) + 4, (job_count - i - 1)*4 );
2041 if (tdb_store(pdb->tdb, key, data, TDB_REPLACE) == -1)
2051 tdb_chainunlock(pdb->tdb, key);
2052 SAFE_FREE(data.dptr);
2053 release_print_db(pdb);
2055 DEBUG(10,("remove_from_jobs_changed: removed jobid %u\n", (unsigned int)jobid ));
2057 DEBUG(10,("remove_from_jobs_changed: Failed to remove jobid %u\n", (unsigned int)jobid ));
2061 /****************************************************************************
2062 Delete a print job - don't update queue.
2063 ****************************************************************************/
2065 static bool print_job_delete1(int snum, uint32 jobid)
2067 const char* sharename = lp_const_servicename(snum);
2068 struct printjob *pjob = print_job_find(sharename, jobid);
2070 struct printif *current_printif = get_printer_fns( snum );
2076 * If already deleting just return.
2079 if (pjob->status == LPQ_DELETING)
2082 /* Hrm - we need to be able to cope with deleting a job before it
2083 has reached the spooler. Just mark it as LPQ_DELETING and
2084 let the print_queue_update() code rmeove the record */
2087 if (pjob->sysjob == -1) {
2088 DEBUG(5, ("attempt to delete job %u not seen by lpr\n", (unsigned int)jobid));
2091 /* Set the tdb entry to be deleting. */
2093 pjob->status = LPQ_DELETING;
2094 pjob_store(server_event_context(), server_messaging_context(),
2095 sharename, jobid, pjob);
2097 if (pjob->spooled && pjob->sysjob != -1)
2099 result = (*(current_printif->job_delete))(
2100 lp_printername(snum),
2101 lp_lprmcommand(snum),
2104 /* Delete the tdb entry if the delete succeeded or the job hasn't
2108 struct tdb_print_db *pdb = get_print_db_byname(sharename);
2113 pjob_delete(server_event_context(),
2114 server_messaging_context(),
2116 /* Ensure we keep a rough count of the number of total jobs... */
2117 tdb_change_int32_atomic(pdb->tdb, "INFO/total_jobs", &njobs, -1);
2118 release_print_db(pdb);
2122 remove_from_jobs_changed( sharename, jobid );
2124 return (result == 0);
2127 /****************************************************************************
2128 Return true if the current user owns the print job.
2129 ****************************************************************************/
2131 static bool is_owner(struct auth_serversupplied_info *server_info,
2132 const char *servicename,
2135 struct printjob *pjob = print_job_find(servicename, jobid);
2137 if (!pjob || !server_info)
2140 return strequal(pjob->user, server_info->sanitized_username);
2143 /****************************************************************************
2145 ****************************************************************************/
2147 WERROR print_job_delete(struct auth_serversupplied_info *server_info,
2148 struct messaging_context *msg_ctx,
2149 int snum, uint32_t jobid)
2151 const char* sharename = lp_const_servicename(snum);
2152 struct printjob *pjob;
2156 owner = is_owner(server_info, lp_const_servicename(snum), jobid);
2158 /* Check access against security descriptor or whether the user
2162 !print_access_check(server_info, msg_ctx, snum,
2163 JOB_ACCESS_ADMINISTER)) {
2164 DEBUG(3, ("delete denied by security descriptor\n"));
2166 /* BEGIN_ADMIN_LOG */
2167 sys_adminlog( LOG_ERR,
2168 "Permission denied-- user not allowed to delete, \
2169 pause, or resume print job. User name: %s. Printer name: %s.",
2170 uidtoname(server_info->utok.uid),
2171 lp_printername(snum) );
2174 return WERR_ACCESS_DENIED;
2178 * get the spooled filename of the print job
2179 * if this works, then the file has not been spooled
2180 * to the underlying print system. Just delete the
2181 * spool file & return.
2184 fname = print_job_fname(sharename, jobid);
2185 if (fname != NULL) {
2186 /* remove the spool file */
2187 DEBUG(10, ("print_job_delete: "
2188 "Removing spool file [%s]\n", fname));
2189 if (unlink(fname) == -1) {
2190 return map_werror_from_unix(errno);
2194 if (!print_job_delete1(snum, jobid)) {
2195 return WERR_ACCESS_DENIED;
2198 /* force update the database and say the delete failed if the
2201 print_queue_update(msg_ctx, snum, True);
2203 pjob = print_job_find(sharename, jobid);
2204 if (pjob && (pjob->status != LPQ_DELETING)) {
2205 return WERR_ACCESS_DENIED;
2208 return WERR_PRINTER_HAS_JOBS_QUEUED;
2211 /****************************************************************************
2213 ****************************************************************************/
2215 bool print_job_pause(struct auth_serversupplied_info *server_info,
2216 struct messaging_context *msg_ctx,
2217 int snum, uint32 jobid, WERROR *errcode)
2219 const char* sharename = lp_const_servicename(snum);
2220 struct printjob *pjob;
2222 struct printif *current_printif = get_printer_fns( snum );
2224 pjob = print_job_find(sharename, jobid);
2226 if (!pjob || !server_info) {
2227 DEBUG(10, ("print_job_pause: no pjob or user for jobid %u\n",
2228 (unsigned int)jobid ));
2232 if (!pjob->spooled || pjob->sysjob == -1) {
2233 DEBUG(10, ("print_job_pause: not spooled or bad sysjob = %d for jobid %u\n",
2234 (int)pjob->sysjob, (unsigned int)jobid ));
2238 if (!is_owner(server_info, lp_const_servicename(snum), jobid) &&
2239 !print_access_check(server_info, msg_ctx, snum,
2240 JOB_ACCESS_ADMINISTER)) {
2241 DEBUG(3, ("pause denied by security descriptor\n"));
2243 /* BEGIN_ADMIN_LOG */
2244 sys_adminlog( LOG_ERR,
2245 "Permission denied-- user not allowed to delete, \
2246 pause, or resume print job. User name: %s. Printer name: %s.",
2247 uidtoname(server_info->utok.uid),
2248 lp_printername(snum) );
2251 *errcode = WERR_ACCESS_DENIED;
2255 /* need to pause the spooled entry */
2256 ret = (*(current_printif->job_pause))(snum, pjob);
2259 *errcode = WERR_INVALID_PARAM;
2263 /* force update the database */
2264 print_cache_flush(lp_const_servicename(snum));
2266 /* Send a printer notify message */
2268 notify_job_status(server_event_context(), msg_ctx, sharename, jobid,
2271 /* how do we tell if this succeeded? */
2276 /****************************************************************************
2278 ****************************************************************************/
2280 bool print_job_resume(struct auth_serversupplied_info *server_info,
2281 struct messaging_context *msg_ctx,
2282 int snum, uint32 jobid, WERROR *errcode)
2284 const char *sharename = lp_const_servicename(snum);
2285 struct printjob *pjob;
2287 struct printif *current_printif = get_printer_fns( snum );
2289 pjob = print_job_find(sharename, jobid);
2291 if (!pjob || !server_info) {
2292 DEBUG(10, ("print_job_resume: no pjob or user for jobid %u\n",
2293 (unsigned int)jobid ));
2297 if (!pjob->spooled || pjob->sysjob == -1) {
2298 DEBUG(10, ("print_job_resume: not spooled or bad sysjob = %d for jobid %u\n",
2299 (int)pjob->sysjob, (unsigned int)jobid ));
2303 if (!is_owner(server_info, lp_const_servicename(snum), jobid) &&
2304 !print_access_check(server_info, msg_ctx, snum,
2305 JOB_ACCESS_ADMINISTER)) {
2306 DEBUG(3, ("resume denied by security descriptor\n"));
2307 *errcode = WERR_ACCESS_DENIED;
2309 /* BEGIN_ADMIN_LOG */
2310 sys_adminlog( LOG_ERR,
2311 "Permission denied-- user not allowed to delete, \
2312 pause, or resume print job. User name: %s. Printer name: %s.",
2313 uidtoname(server_info->utok.uid),
2314 lp_printername(snum) );
2319 ret = (*(current_printif->job_resume))(snum, pjob);
2322 *errcode = WERR_INVALID_PARAM;
2326 /* force update the database */
2327 print_cache_flush(lp_const_servicename(snum));
2329 /* Send a printer notify message */
2331 notify_job_status(server_event_context(), msg_ctx, sharename, jobid,
2337 /****************************************************************************
2338 Write to a print file.
2339 ****************************************************************************/
2341 ssize_t print_job_write(int snum, uint32 jobid, const char *buf, SMB_OFF_T pos, size_t size)
2343 const char* sharename = lp_const_servicename(snum);
2344 ssize_t return_code;
2345 struct printjob *pjob;
2347 pjob = print_job_find(sharename, jobid);
2351 /* don't allow another process to get this info - it is meaningless */
2352 if (pjob->pid != sys_getpid())
2355 /* if SMBD is spooling this can't be allowed */
2356 if (pjob->status == PJOB_SMBD_SPOOLING) {
2360 return_code = write_data_at_offset(pjob->fd, buf, size, pos);
2362 if (return_code>0) {
2364 pjob_store(server_event_context(), server_messaging_context(),
2365 sharename, jobid, pjob);
2370 /****************************************************************************
2371 Get the queue status - do not update if db is out of date.
2372 ****************************************************************************/
2374 static int get_queue_status(const char* sharename, print_status_struct *status)
2378 struct tdb_print_db *pdb = get_print_db_byname(sharename);
2382 ZERO_STRUCTP(status);
2389 fstr_sprintf(keystr, "STATUS/%s", sharename);
2390 data = tdb_fetch(pdb->tdb, string_tdb_data(keystr));
2392 if (data.dsize == sizeof(print_status_struct))
2393 /* this memcpy is ok since the status struct was
2394 not packed before storing it in the tdb */
2395 memcpy(status, data.dptr, sizeof(print_status_struct));
2396 SAFE_FREE(data.dptr);
2399 len = tdb_fetch_int32(pdb->tdb, "INFO/total_jobs");
2400 release_print_db(pdb);
2401 return (len == -1 ? 0 : len);
2404 /****************************************************************************
2405 Determine the number of jobs in a queue.
2406 ****************************************************************************/
2408 int print_queue_length(struct messaging_context *msg_ctx, int snum,
2409 print_status_struct *pstatus)
2411 const char* sharename = lp_const_servicename( snum );
2412 print_status_struct status;
2415 ZERO_STRUCT( status );
2417 /* make sure the database is up to date */
2418 if (print_cache_expired(lp_const_servicename(snum), True))
2419 print_queue_update(msg_ctx, snum, False);
2421 /* also fetch the queue status */
2422 memset(&status, 0, sizeof(status));
2423 len = get_queue_status(sharename, &status);
2431 /***************************************************************************
2432 Allocate a jobid. Hold the lock for as short a time as possible.
2433 ***************************************************************************/
2435 static WERROR allocate_print_jobid(struct tdb_print_db *pdb, int snum,
2436 const char *sharename, uint32 *pjobid)
2440 enum TDB_ERROR terr;
2443 *pjobid = (uint32)-1;
2445 for (i = 0; i < 3; i++) {
2446 /* Lock the database - only wait 20 seconds. */
2447 ret = tdb_lock_bystring_with_timeout(pdb->tdb,
2448 "INFO/nextjob", 20);
2450 DEBUG(0, ("allocate_print_jobid: "
2451 "Failed to lock printing database %s\n",
2453 terr = tdb_error(pdb->tdb);
2454 return ntstatus_to_werror(map_nt_error_from_tdb(terr));
2457 if (!tdb_fetch_uint32(pdb->tdb, "INFO/nextjob", &jobid)) {
2458 terr = tdb_error(pdb->tdb);
2459 if (terr != TDB_ERR_NOEXIST) {
2460 DEBUG(0, ("allocate_print_jobid: "
2461 "Failed to fetch INFO/nextjob "
2462 "for print queue %s\n", sharename));
2463 tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
2464 return ntstatus_to_werror(map_nt_error_from_tdb(terr));
2466 DEBUG(10, ("allocate_print_jobid: "
2467 "No existing jobid in %s\n", sharename));
2471 DEBUG(10, ("allocate_print_jobid: "
2472 "Read jobid %u from %s\n", jobid, sharename));
2474 jobid = NEXT_JOBID(jobid);
2476 ret = tdb_store_int32(pdb->tdb, "INFO/nextjob", jobid);
2478 terr = tdb_error(pdb->tdb);
2479 DEBUG(3, ("allocate_print_jobid: "
2480 "Failed to store INFO/nextjob.\n"));
2481 tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
2482 return ntstatus_to_werror(map_nt_error_from_tdb(terr));
2485 /* We've finished with the INFO/nextjob lock. */
2486 tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
2488 if (!print_job_exists(sharename, jobid)) {
2491 DEBUG(10, ("allocate_print_jobid: "
2492 "Found jobid %u in %s\n", jobid, sharename));
2496 DEBUG(0, ("allocate_print_jobid: "
2497 "Failed to allocate a print job for queue %s\n",
2499 /* Probably full... */
2500 return WERR_NO_SPOOL_SPACE;
2503 /* Store a dummy placeholder. */
2509 if (tdb_store(pdb->tdb, print_key(jobid, &tmp), dum,
2510 TDB_INSERT) == -1) {
2511 DEBUG(3, ("allocate_print_jobid: "
2512 "jobid (%d) failed to store placeholder.\n",
2514 terr = tdb_error(pdb->tdb);
2515 return ntstatus_to_werror(map_nt_error_from_tdb(terr));
2523 /***************************************************************************
2524 Append a jobid to the 'jobs changed' list.
2525 ***************************************************************************/
2527 static bool add_to_jobs_changed(struct tdb_print_db *pdb, uint32 jobid)
2532 SIVAL(&store_jobid, 0, jobid);
2533 data.dptr = (uint8 *)&store_jobid;
2536 DEBUG(10,("add_to_jobs_changed: Added jobid %u\n", (unsigned int)jobid ));
2538 return (tdb_append(pdb->tdb, string_tdb_data("INFO/jobs_changed"),
2543 /***************************************************************************
2544 Do all checks needed to determine if we can start a job.
2545 ***************************************************************************/
2547 static WERROR print_job_checks(struct auth_serversupplied_info *server_info,
2548 struct messaging_context *msg_ctx,
2549 int snum, int *njobs)
2551 const char *sharename = lp_const_servicename(snum);
2552 uint64_t dspace, dsize;
2556 if (!print_access_check(server_info, msg_ctx, snum,
2557 PRINTER_ACCESS_USE)) {
2558 DEBUG(3, ("print_job_checks: "
2559 "job start denied by security descriptor\n"));
2560 return WERR_ACCESS_DENIED;
2563 if (!print_time_access_check(server_info, msg_ctx, sharename)) {
2564 DEBUG(3, ("print_job_checks: "
2565 "job start denied by time check\n"));
2566 return WERR_ACCESS_DENIED;
2569 /* see if we have sufficient disk space */
2570 if (lp_minprintspace(snum)) {
2571 minspace = lp_minprintspace(snum);
2572 ret = sys_fsusage(lp_pathname(snum), &dspace, &dsize);
2573 if (ret == 0 && dspace < 2*minspace) {
2574 DEBUG(3, ("print_job_checks: "
2575 "disk space check failed.\n"));
2576 return WERR_NO_SPOOL_SPACE;
2580 /* for autoloaded printers, check that the printcap entry still exists */
2581 if (lp_autoloaded(snum) && !pcap_printername_ok(sharename)) {
2582 DEBUG(3, ("print_job_checks: printer name %s check failed.\n",
2584 return WERR_ACCESS_DENIED;
2587 /* Insure the maximum queue size is not violated */
2588 *njobs = print_queue_length(msg_ctx, snum, NULL);
2589 if (*njobs > lp_maxprintjobs(snum)) {
2590 DEBUG(3, ("print_job_checks: Queue %s number of jobs (%d) "
2591 "larger than max printjobs per queue (%d).\n",
2592 sharename, *njobs, lp_maxprintjobs(snum)));
2593 return WERR_NO_SPOOL_SPACE;
2599 /***************************************************************************
2601 ***************************************************************************/
2603 static WERROR print_job_spool_file(int snum, uint32_t jobid,
2604 const char *output_file,
2605 struct printjob *pjob)
2612 /* if this file is within the printer path, it means that smbd
2613 * is spooling it and will pass us control when it is finished.
2614 * Verify that the file name is ok, within path, and it is
2615 * already already there */
2617 path = lp_pathname(snum);
2619 if (strncmp(output_file, path, len) == 0 &&
2620 (output_file[len - 1] == '/' || output_file[len] == '/')) {
2622 /* verify path is not too long */
2623 if (strlen(output_file) >= sizeof(pjob->filename)) {
2624 return WERR_INVALID_NAME;
2627 /* verify that the file exists */
2628 if (sys_stat(output_file, &st, false) != 0) {
2629 return WERR_INVALID_NAME;
2632 fstrcpy(pjob->filename, output_file);
2634 DEBUG(3, ("print_job_spool_file:"
2635 "External spooling activated"));
2637 /* we do not open the file until spooling is done */
2639 pjob->status = PJOB_SMBD_SPOOLING;
2645 slprintf(pjob->filename, sizeof(pjob->filename)-1,
2646 "%s/%s%.8u.XXXXXX", lp_pathname(snum),
2647 PRINT_SPOOL_PREFIX, (unsigned int)jobid);
2648 pjob->fd = mkstemp(pjob->filename);
2650 if (pjob->fd == -1) {
2651 werr = map_werror_from_unix(errno);
2652 if (W_ERROR_EQUAL(werr, WERR_ACCESS_DENIED)) {
2653 /* Common setup error, force a report. */
2654 DEBUG(0, ("print_job_spool_file: "
2655 "insufficient permissions to open spool "
2656 "file %s.\n", pjob->filename));
2658 /* Normal case, report at level 3 and above. */
2659 DEBUG(3, ("print_job_spool_file: "
2660 "can't open spool file %s\n",
2669 /***************************************************************************
2670 Start spooling a job - return the jobid.
2671 ***************************************************************************/
2673 WERROR print_job_start(struct auth_serversupplied_info *server_info,
2674 struct messaging_context *msg_ctx,
2675 int snum, const char *docname, const char *filename,
2676 struct spoolss_DeviceMode *devmode, uint32_t *_jobid)
2680 struct printjob pjob;
2681 const char *sharename = lp_const_servicename(snum);
2682 struct tdb_print_db *pdb = get_print_db_byname(sharename);
2687 return WERR_INTERNAL_DB_CORRUPTION;
2690 path = lp_pathname(snum);
2692 werr = print_job_checks(server_info, msg_ctx, snum, &njobs);
2693 if (!W_ERROR_IS_OK(werr)) {
2694 release_print_db(pdb);
2698 DEBUG(10, ("print_job_start: "
2699 "Queue %s number of jobs (%d), max printjobs = %d\n",
2700 sharename, njobs, lp_maxprintjobs(snum)));
2702 werr = allocate_print_jobid(pdb, snum, sharename, &jobid);
2703 if (!W_ERROR_IS_OK(werr)) {
2707 /* create the database entry */
2711 pjob.pid = sys_getpid();
2714 pjob.starttime = time(NULL);
2715 pjob.status = LPQ_SPOOLING;
2717 pjob.spooled = False;
2719 pjob.devmode = devmode;
2721 fstrcpy(pjob.jobname, docname);
2723 fstrcpy(pjob.user, lp_printjob_username(snum));
2724 standard_sub_advanced(sharename, server_info->sanitized_username,
2725 path, server_info->utok.gid,
2726 server_info->sanitized_username,
2727 server_info->info3->base.domain.string,
2728 pjob.user, sizeof(pjob.user)-1);
2729 /* ensure NULL termination */
2730 pjob.user[sizeof(pjob.user)-1] = '\0';
2732 fstrcpy(pjob.queuename, lp_const_servicename(snum));
2734 /* we have a job entry - now create the spool file */
2735 werr = print_job_spool_file(snum, jobid, filename, &pjob);
2736 if (!W_ERROR_IS_OK(werr)) {
2740 pjob_store(server_event_context(), msg_ctx, sharename, jobid, &pjob);
2742 /* Update the 'jobs changed' entry used by print_queue_status. */
2743 add_to_jobs_changed(pdb, jobid);
2745 /* Ensure we keep a rough count of the number of total jobs... */
2746 tdb_change_int32_atomic(pdb->tdb, "INFO/total_jobs", &njobs, 1);
2748 release_print_db(pdb);
2755 pjob_delete(server_event_context(), msg_ctx, sharename, jobid);
2758 release_print_db(pdb);
2760 DEBUG(3, ("print_job_start: returning fail. "
2761 "Error = %s\n", win_errstr(werr)));
2765 /****************************************************************************
2766 Update the number of pages spooled to jobid
2767 ****************************************************************************/
2769 void print_job_endpage(int snum, uint32 jobid)
2771 const char* sharename = lp_const_servicename(snum);
2772 struct printjob *pjob;
2774 pjob = print_job_find(sharename, jobid);
2777 /* don't allow another process to get this info - it is meaningless */
2778 if (pjob->pid != sys_getpid())
2782 pjob_store(server_event_context(), server_messaging_context(),
2783 sharename, jobid, pjob);
2786 /****************************************************************************
2787 Print a file - called on closing the file. This spools the job.
2788 If normal close is false then we're tearing down the jobs - treat as an
2790 ****************************************************************************/
2792 NTSTATUS print_job_end(struct messaging_context *msg_ctx, int snum,
2793 uint32 jobid, enum file_close_type close_type)
2795 const char* sharename = lp_const_servicename(snum);
2796 struct printjob *pjob;
2798 SMB_STRUCT_STAT sbuf;
2799 struct printif *current_printif = get_printer_fns( snum );
2800 NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
2802 pjob = print_job_find(sharename, jobid);
2805 return NT_STATUS_PRINT_CANCELLED;
2808 if (pjob->spooled || pjob->pid != sys_getpid()) {
2809 return NT_STATUS_ACCESS_DENIED;
2812 if (close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) {
2813 if (pjob->status == PJOB_SMBD_SPOOLING) {
2814 /* take over the file now, smbd is done */
2815 if (sys_stat(pjob->filename, &sbuf, false) != 0) {
2816 status = map_nt_error_from_unix(errno);
2817 DEBUG(3, ("print_job_end: "
2818 "stat file failed for jobid %d\n",
2823 pjob->status = LPQ_SPOOLING;
2827 if ((sys_fstat(pjob->fd, &sbuf, false) != 0)) {
2828 status = map_nt_error_from_unix(errno);
2830 DEBUG(3, ("print_job_end: "
2831 "stat file failed for jobid %d\n",
2839 pjob->size = sbuf.st_ex_size;
2843 * Not a normal close, something has gone wrong. Cleanup.
2845 if (pjob->fd != -1) {
2851 /* Technically, this is not quite right. If the printer has a separator
2852 * page turned on, the NT spooler prints the separator page even if the
2853 * print job is 0 bytes. 010215 JRR */
2854 if (pjob->size == 0 || pjob->status == LPQ_DELETING) {
2855 /* don't bother spooling empty files or something being deleted. */
2856 DEBUG(5,("print_job_end: canceling spool of %s (%s)\n",
2857 pjob->filename, pjob->size ? "deleted" : "zero length" ));
2858 unlink(pjob->filename);
2859 pjob_delete(server_event_context(), msg_ctx, sharename, jobid);
2860 return NT_STATUS_OK;
2863 ret = (*(current_printif->job_submit))(snum, pjob);
2866 status = NT_STATUS_PRINT_CANCELLED;
2870 /* The print job has been successfully handed over to the back-end */
2872 pjob->spooled = True;
2873 pjob->status = LPQ_QUEUED;
2874 pjob_store(server_event_context(), msg_ctx, sharename, jobid, pjob);
2876 /* make sure the database is up to date */
2877 if (print_cache_expired(lp_const_servicename(snum), True))
2878 print_queue_update(msg_ctx, snum, False);
2880 return NT_STATUS_OK;
2884 /* The print job was not successfully started. Cleanup */
2885 /* Still need to add proper error return propagation! 010122:JRR */
2887 unlink(pjob->filename);
2888 pjob_delete(server_event_context(), msg_ctx, sharename, jobid);
2892 /****************************************************************************
2893 Get a snapshot of jobs in the system without traversing.
2894 ****************************************************************************/
2896 static bool get_stored_queue_info(struct messaging_context *msg_ctx,
2897 struct tdb_print_db *pdb, int snum,
2898 int *pcount, print_queue_struct **ppqueue)
2900 TDB_DATA data, cgdata;
2901 print_queue_struct *queue = NULL;
2903 uint32 extra_count = 0;
2904 int total_count = 0;
2907 int max_reported_jobs = lp_max_reported_jobs(snum);
2909 const char* sharename = lp_servicename(snum);
2911 /* make sure the database is up to date */
2912 if (print_cache_expired(lp_const_servicename(snum), True))
2913 print_queue_update(msg_ctx, snum, False);
2919 ZERO_STRUCT(cgdata);
2921 /* Get the stored queue data. */
2922 data = tdb_fetch(pdb->tdb, string_tdb_data("INFO/linear_queue_array"));
2924 if (data.dptr && data.dsize >= sizeof(qcount))
2925 len += tdb_unpack(data.dptr + len, data.dsize - len, "d", &qcount);
2927 /* Get the changed jobs list. */
2928 cgdata = tdb_fetch(pdb->tdb, string_tdb_data("INFO/jobs_changed"));
2929 if (cgdata.dptr != NULL && (cgdata.dsize % 4 == 0))
2930 extra_count = cgdata.dsize/4;
2932 DEBUG(5,("get_stored_queue_info: qcount = %u, extra_count = %u\n", (unsigned int)qcount, (unsigned int)extra_count));
2934 /* Allocate the queue size. */
2935 if (qcount == 0 && extra_count == 0)
2938 if ((queue = SMB_MALLOC_ARRAY(print_queue_struct, qcount + extra_count)) == NULL)
2941 /* Retrieve the linearised queue data. */
2943 for( i = 0; i < qcount; i++) {
2944 uint32 qjob, qsize, qpage_count, qstatus, qpriority, qtime;
2945 len += tdb_unpack(data.dptr + len, data.dsize - len, "ddddddff",
2954 queue[i].job = qjob;
2955 queue[i].size = qsize;
2956 queue[i].page_count = qpage_count;
2957 queue[i].status = qstatus;
2958 queue[i].priority = qpriority;
2959 queue[i].time = qtime;
2962 total_count = qcount;
2964 /* Add in the changed jobids. */
2965 for( i = 0; i < extra_count; i++) {
2967 struct printjob *pjob;
2969 jobid = IVAL(cgdata.dptr, i*4);
2970 DEBUG(5,("get_stored_queue_info: changed job = %u\n", (unsigned int)jobid));
2971 pjob = print_job_find(lp_const_servicename(snum), jobid);
2973 DEBUG(5,("get_stored_queue_info: failed to find changed job = %u\n", (unsigned int)jobid));
2974 remove_from_jobs_changed(sharename, jobid);
2978 queue[total_count].job = jobid;
2979 queue[total_count].size = pjob->size;
2980 queue[total_count].page_count = pjob->page_count;
2981 queue[total_count].status = pjob->status;
2982 queue[total_count].priority = 1;
2983 queue[total_count].time = pjob->starttime;
2984 fstrcpy(queue[total_count].fs_user, pjob->user);
2985 fstrcpy(queue[total_count].fs_file, pjob->jobname);
2989 /* Sort the queue by submission time otherwise they are displayed
2992 TYPESAFE_QSORT(queue, total_count, printjob_comp);
2994 DEBUG(5,("get_stored_queue_info: total_count = %u\n", (unsigned int)total_count));
2996 if (max_reported_jobs && total_count > max_reported_jobs)
2997 total_count = max_reported_jobs;
3000 *pcount = total_count;
3006 SAFE_FREE(data.dptr);
3007 SAFE_FREE(cgdata.dptr);
3011 /****************************************************************************
3012 Get a printer queue listing.
3013 set queue = NULL and status = NULL if you just want to update the cache
3014 ****************************************************************************/
3016 int print_queue_status(struct messaging_context *msg_ctx, int snum,
3017 print_queue_struct **ppqueue,
3018 print_status_struct *status)
3022 const char *sharename;
3023 struct tdb_print_db *pdb;
3026 /* make sure the database is up to date */
3028 if (print_cache_expired(lp_const_servicename(snum), True))
3029 print_queue_update(msg_ctx, snum, False);
3031 /* return if we are done */
3032 if ( !ppqueue || !status )
3036 sharename = lp_const_servicename(snum);
3037 pdb = get_print_db_byname(sharename);
3043 * Fetch the queue status. We must do this first, as there may
3044 * be no jobs in the queue.
3047 ZERO_STRUCTP(status);
3048 slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", sharename);
3049 key = string_tdb_data(keystr);
3051 data = tdb_fetch(pdb->tdb, key);
3053 if (data.dsize == sizeof(*status)) {
3054 /* this memcpy is ok since the status struct was
3055 not packed before storing it in the tdb */
3056 memcpy(status, data.dptr, sizeof(*status));
3058 SAFE_FREE(data.dptr);
3062 * Now, fetch the print queue information. We first count the number
3063 * of entries, and then only retrieve the queue if necessary.
3066 if (!get_stored_queue_info(msg_ctx, pdb, snum, &count, ppqueue)) {
3067 release_print_db(pdb);
3071 release_print_db(pdb);
3075 /****************************************************************************
3077 ****************************************************************************/
3079 WERROR print_queue_pause(struct auth_serversupplied_info *server_info,
3080 struct messaging_context *msg_ctx, int snum)
3083 struct printif *current_printif = get_printer_fns( snum );
3085 if (!print_access_check(server_info, msg_ctx, snum,
3086 PRINTER_ACCESS_ADMINISTER)) {
3087 return WERR_ACCESS_DENIED;
3093 ret = (*(current_printif->queue_pause))(snum);
3098 return WERR_INVALID_PARAM;
3101 /* force update the database */
3102 print_cache_flush(lp_const_servicename(snum));
3104 /* Send a printer notify message */
3106 notify_printer_status(server_event_context(), msg_ctx, snum,
3107 PRINTER_STATUS_PAUSED);
3112 /****************************************************************************
3114 ****************************************************************************/
3116 WERROR print_queue_resume(struct auth_serversupplied_info *server_info,
3117 struct messaging_context *msg_ctx, int snum)
3120 struct printif *current_printif = get_printer_fns( snum );
3122 if (!print_access_check(server_info, msg_ctx, snum,
3123 PRINTER_ACCESS_ADMINISTER)) {
3124 return WERR_ACCESS_DENIED;
3129 ret = (*(current_printif->queue_resume))(snum);
3134 return WERR_INVALID_PARAM;
3137 /* make sure the database is up to date */
3138 if (print_cache_expired(lp_const_servicename(snum), True))
3139 print_queue_update(msg_ctx, snum, True);
3141 /* Send a printer notify message */
3143 notify_printer_status(server_event_context(), msg_ctx, snum,
3149 /****************************************************************************
3150 Purge a queue - implemented by deleting all jobs that we can delete.
3151 ****************************************************************************/
3153 WERROR print_queue_purge(struct auth_serversupplied_info *server_info,
3154 struct messaging_context *msg_ctx, int snum)
3156 print_queue_struct *queue;
3157 print_status_struct status;
3161 /* Force and update so the count is accurate (i.e. not a cached count) */
3162 print_queue_update(msg_ctx, snum, True);
3164 can_job_admin = print_access_check(server_info,
3167 JOB_ACCESS_ADMINISTER);
3168 njobs = print_queue_status(msg_ctx, snum, &queue, &status);
3170 if ( can_job_admin )
3173 for (i=0;i<njobs;i++) {
3174 bool owner = is_owner(server_info, lp_const_servicename(snum),
3177 if (owner || can_job_admin) {
3178 print_job_delete1(snum, queue[i].job);
3182 if ( can_job_admin )
3185 /* update the cache */
3186 print_queue_update(msg_ctx, snum, True);