Adding upstream version 2:4.17.12+dfsg.upstream/2%4.17.12+dfsgupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 3266 insertions, 0 deletions

diff --git a/source3/printing/printing.c b/source3/printing/printing.c
new file mode 100644
index 0000000..dbe5a20
--- /dev/null
+++ b/source3/printing/printing.c
@@ -0,0 +1,3266 @@
+/*
+   Unix SMB/Netbios implementation.
+   Version 3.0
+   printing backend routines
+   Copyright (C) Andrew Tridgell 1992-2000
+   Copyright (C) Jeremy Allison 2002
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "smbd/globals.h"
+#include "system/syslog.h"
+#include "system/filesys.h"
+#include "printing.h"
+#include "../librpc/gen_ndr/ndr_spoolss.h"
+#include "nt_printing.h"
+#include "../librpc/gen_ndr/netlogon.h"
+#include "printing/notify.h"
+#include "printing/pcap.h"
+#include "printing/printer_list.h"
+#include "printing/queue_process.h"
+#include "serverid.h"
+#include "smbd/smbd.h"
+#include "auth.h"
+#include "messages.h"
+#include "util_tdb.h"
+#include "lib/param/loadparm.h"
+#include "lib/util/sys_rw_data.h"
+#include "lib/util/string_wrappers.h"
+#include "lib/global_contexts.h"
+#include "source3/printing/rap_jobid.h"
+#include "source3/lib/substitute.h"
+
+extern userdom_struct current_user_info;
+
+/* Current printer interface */
+static bool remove_from_jobs_added(const char* sharename, uint32_t jobid);
+
+static int get_queue_status(const char* sharename, print_status_struct *);
+
+/****************************************************************************
+ Initialise the printing backend. Called once at startup before the fork().
+****************************************************************************/
+
+bool print_backend_init(struct messaging_context *msg_ctx)
+{
+	const char *sversion = "INFO/version";
+	int services = lp_numservices();
+	int snum;
+	bool ok;
+	char *print_cache_path;
+
+	print_cache_path = cache_path(talloc_tos(), "printing");
+	if (print_cache_path == NULL) {
+		return false;
+	}
+	ok = directory_create_or_exist(print_cache_path, 0755);
+	TALLOC_FREE(print_cache_path);
+	if (!ok) {
+		return false;
+	}
+
+	/* handle a Samba upgrade */
+
+	for (snum = 0; snum < services; snum++) {
+		struct tdb_print_db *pdb;
+		if (!lp_printable(snum))
+			continue;
+
+		pdb = get_print_db_byname(lp_const_servicename(snum));
+		if (!pdb)
+			continue;
+		if (tdb_lock_bystring(pdb->tdb, sversion) != 0) {
+			DEBUG(0,("print_backend_init: Failed to open printer %s database\n", lp_const_servicename(snum) ));
+			release_print_db(pdb);
+			return False;
+		}
+		if (tdb_fetch_int32(pdb->tdb, sversion) != PRINT_DATABASE_VERSION) {
+			tdb_wipe_all(pdb->tdb);
+			tdb_store_int32(pdb->tdb, sversion, PRINT_DATABASE_VERSION);
+		}
+		tdb_unlock_bystring(pdb->tdb, sversion);
+		release_print_db(pdb);
+	}
+
+	close_all_print_db(); /* Don't leave any open. */
+
+	/* do NT print initialization... */
+	return nt_printing_init(msg_ctx);
+}
+
+/****************************************************************************
+ Shut down printing backend. Called once at shutdown to close the tdb.
+****************************************************************************/
+
+void printing_end(void)
+{
+	close_all_print_db(); /* Don't leave any open. */
+}
+
+/****************************************************************************
+ Retrieve the set of printing functions for a given service.  This allows
+ us to set the printer function table based on the value of the 'printing'
+ service parameter.
+
+ Use the generic interface as the default and only use cups interface only
+ when asked for (and only when supported)
+****************************************************************************/
+
+static struct printif *get_printer_fns_from_type( enum printing_types type )
+{
+	struct printif *printer_fns = &generic_printif;
+
+#ifdef HAVE_CUPS
+	if ( type == PRINT_CUPS ) {
+		printer_fns = &cups_printif;
+	}
+#endif /* HAVE_CUPS */
+
+#ifdef HAVE_IPRINT
+	if ( type == PRINT_IPRINT ) {
+		printer_fns = &iprint_printif;
+	}
+#endif /* HAVE_IPRINT */
+
+	printer_fns->type = type;
+
+	return printer_fns;
+}
+
+static struct printif *get_printer_fns( int snum )
+{
+	return get_printer_fns_from_type( (enum printing_types)lp_printing(snum) );
+}
+
+
+/****************************************************************************
+ Useful function to generate a tdb key.
+****************************************************************************/
+
+static TDB_DATA print_key(uint32_t jobid, uint32_t *tmp)
+{
+	TDB_DATA ret;
+
+	SIVAL(tmp, 0, jobid);
+	ret.dptr = (uint8_t *)tmp;
+	ret.dsize = sizeof(*tmp);
+	return ret;
+}
+
+/****************************************************************************
+ Pack the devicemode to store it in a tdb.
+****************************************************************************/
+static int pack_devicemode(struct spoolss_DeviceMode *devmode, uint8_t *buf, int buflen)
+{
+	enum ndr_err_code ndr_err;
+	DATA_BLOB blob = { .data = NULL };
+	int len = 0;
+
+	if (devmode) {
+		ndr_err = ndr_push_struct_blob(&blob, talloc_tos(),
+					       devmode,
+					       (ndr_push_flags_fn_t)
+					       ndr_push_spoolss_DeviceMode);
+		if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+			DEBUG(10, ("pack_devicemode: "
+				   "error encoding spoolss_DeviceMode\n"));
+			goto done;
+		}
+	}
+
+	len = tdb_pack(buf, buflen, "B", blob.length, blob.data);
+
+	if (devmode) {
+		DEBUG(8, ("Packed devicemode [%s]\n", devmode->formname));
+	}
+
+done:
+	return len;
+}
+
+/****************************************************************************
+ Unpack the devicemode to store it in a tdb.
+****************************************************************************/
+static int unpack_devicemode(TALLOC_CTX *mem_ctx,
+		      const uint8_t *buf, int buflen,
+		      struct spoolss_DeviceMode **devmode)
+{
+	struct spoolss_DeviceMode *dm;
+	enum ndr_err_code ndr_err;
+	char *data = NULL;
+	uint32_t data_len = 0;
+	DATA_BLOB blob;
+	int len = 0;
+
+	*devmode = NULL;
+
+	len = tdb_unpack(buf, buflen, "B", &data_len, &data);
+	if (!data) {
+		return len;
+	}
+
+	dm = talloc_zero(mem_ctx, struct spoolss_DeviceMode);
+	if (!dm) {
+		goto done;
+	}
+
+	blob = data_blob_const(data, data_len);
+
+	ndr_err = ndr_pull_struct_blob(&blob, dm, dm,
+			(ndr_pull_flags_fn_t)ndr_pull_spoolss_DeviceMode);
+	if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+		DEBUG(10, ("unpack_devicemode: "
+			   "error parsing spoolss_DeviceMode\n"));
+		goto done;
+	}
+
+	DEBUG(8, ("Unpacked devicemode [%s](%s)\n",
+		  dm->devicename, dm->formname));
+	if (dm->driverextra_data.data) {
+		DEBUG(8, ("with a private section of %d bytes\n",
+			  dm->__driverextra_length));
+	}
+
+	*devmode = dm;
+
+done:
+	SAFE_FREE(data);
+	return len;
+}
+
+/***********************************************************************
+ unpack a pjob from a tdb buffer
+***********************************************************************/
+
+static int unpack_pjob(TALLOC_CTX *mem_ctx, uint8_t *buf, int buflen,
+		       struct printjob *pjob)
+{
+	int	len = 0;
+	int	used;
+	uint32_t pjpid, pjjobid, pjsysjob, pjfd, pjstarttime, pjstatus;
+	uint32_t pjsize, pjpage_count, pjspooled, pjsmbjob;
+
+	if (!buf || !pjob) {
+		return -1;
+	}
+
+	len += tdb_unpack(buf+len, buflen-len, "ddddddddddfffff",
+				&pjpid,
+				&pjjobid,
+				&pjsysjob,
+				&pjfd,
+				&pjstarttime,
+				&pjstatus,
+				&pjsize,
+				&pjpage_count,
+				&pjspooled,
+				&pjsmbjob,
+				pjob->filename,
+				pjob->jobname,
+				pjob->user,
+				pjob->clientmachine,
+				pjob->queuename);
+
+	if (len == -1) {
+		return -1;
+	}
+
+        used = unpack_devicemode(mem_ctx, buf+len, buflen-len, &pjob->devmode);
+        if (used == -1) {
+		return -1;
+        }
+
+	len += used;
+
+	pjob->pid = pjpid;
+	pjob->jobid = pjjobid;
+	pjob->sysjob = pjsysjob;
+	pjob->fd = pjfd;
+	pjob->starttime = pjstarttime;
+	pjob->status = pjstatus;
+	pjob->size = pjsize;
+	pjob->page_count = pjpage_count;
+	pjob->spooled = pjspooled;
+	pjob->smbjob = pjsmbjob;
+
+	return len;
+
+}
+
+/****************************************************************************
+ Useful function to find a print job in the database.
+****************************************************************************/
+
+static struct printjob *print_job_find(TALLOC_CTX *mem_ctx,
+				       const char *sharename,
+				       uint32_t jobid)
+{
+	struct printjob		*pjob;
+	uint32_t tmp;
+	TDB_DATA 		ret;
+	struct tdb_print_db 	*pdb = get_print_db_byname(sharename);
+
+	DEBUG(10,("print_job_find: looking up job %u for share %s\n",
+			(unsigned int)jobid, sharename ));
+
+	if (!pdb) {
+		return NULL;
+	}
+
+	ret = tdb_fetch(pdb->tdb, print_key(jobid, &tmp));
+	release_print_db(pdb);
+
+	if (!ret.dptr) {
+		DEBUG(10, ("print_job_find: failed to find jobid %u.\n",
+			   jobid));
+		return NULL;
+	}
+
+	pjob = talloc_zero(mem_ctx, struct printjob);
+	if (pjob == NULL) {
+		goto err_out;
+	}
+
+	if (unpack_pjob(mem_ctx, ret.dptr, ret.dsize, pjob) == -1) {
+		DEBUG(10, ("failed to unpack jobid %u.\n", jobid));
+		talloc_free(pjob);
+		pjob = NULL;
+		goto err_out;
+	}
+
+	DEBUG(10,("print_job_find: returning system job %d for jobid %u.\n",
+		  pjob->sysjob, jobid));
+	SMB_ASSERT(pjob->jobid == jobid);
+
+err_out:
+	SAFE_FREE(ret.dptr);
+	return pjob;
+}
+
+struct job_traverse_state {
+	int sysjob;
+	uint32_t jobid;
+};
+
+/* find spoolss jobid based on sysjob */
+static int sysjob_to_jobid_traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA key,
+				       TDB_DATA data, void *private_data)
+{
+	struct printjob *pjob;
+	struct job_traverse_state *state =
+		(struct job_traverse_state *)private_data;
+
+	if (!data.dptr || data.dsize == 0)
+		return 0;
+
+	pjob = (struct printjob *)data.dptr;
+	if (key.dsize != sizeof(uint32_t))
+		return 0;
+
+	if (state->sysjob == pjob->sysjob) {
+		state->jobid = pjob->jobid;
+		return 1;
+	}
+
+	return 0;
+}
+
+uint32_t sysjob_to_jobid_pdb(struct tdb_print_db *pdb, int sysjob)
+{
+	struct job_traverse_state state;
+
+	state.sysjob = sysjob;
+	state.jobid = (uint32_t)-1;
+
+	tdb_traverse(pdb->tdb, sysjob_to_jobid_traverse_fn, &state);
+
+	return state.jobid;
+}
+
+/****************************************************************************
+ This is a *horribly expensive call as we have to iterate through all the
+ current printer tdb's. Don't do this often ! JRA.
+****************************************************************************/
+
+uint32_t sysjob_to_jobid(int unix_jobid)
+{
+	int services = lp_numservices();
+	int snum;
+	struct job_traverse_state state;
+
+	state.sysjob = unix_jobid;
+	state.jobid = (uint32_t)-1;
+
+	for (snum = 0; snum < services; snum++) {
+		struct tdb_print_db *pdb;
+		if (!lp_printable(snum))
+			continue;
+		pdb = get_print_db_byname(lp_const_servicename(snum));
+		if (!pdb) {
+			continue;
+		}
+		tdb_traverse(pdb->tdb, sysjob_to_jobid_traverse_fn, &state);
+		release_print_db(pdb);
+		if (state.jobid != (uint32_t)-1)
+			return state.jobid;
+	}
+	return (uint32_t)-1;
+}
+
+/* find sysjob based on spoolss jobid */
+static int jobid_to_sysjob_traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA key,
+				       TDB_DATA data, void *private_data)
+{
+	struct printjob *pjob;
+	struct job_traverse_state *state =
+		(struct job_traverse_state *)private_data;
+
+	if (!data.dptr || data.dsize == 0)
+		return 0;
+
+	pjob = (struct printjob *)data.dptr;
+	if (key.dsize != sizeof(uint32_t))
+		return 0;
+
+	if (state->jobid == pjob->jobid) {
+		state->sysjob = pjob->sysjob;
+		return 1;
+	}
+
+	return 0;
+}
+
+int jobid_to_sysjob_pdb(struct tdb_print_db *pdb, uint32_t jobid)
+{
+	struct job_traverse_state state;
+
+	state.sysjob = -1;
+	state.jobid = jobid;
+
+	tdb_traverse(pdb->tdb, jobid_to_sysjob_traverse_fn, &state);
+
+	return state.sysjob;
+}
+
+/****************************************************************************
+ Send notifications based on what has changed after a pjob_store.
+****************************************************************************/
+
+static const struct {
+	uint32_t lpq_status;
+	uint32_t spoolss_status;
+} lpq_to_spoolss_status_map[] = {
+	{ LPQ_QUEUED, JOB_STATUS_QUEUED },
+	{ LPQ_PAUSED, JOB_STATUS_PAUSED },
+	{ LPQ_SPOOLING, JOB_STATUS_SPOOLING },
+	{ LPQ_PRINTING, JOB_STATUS_PRINTING },
+	{ LPQ_DELETING, JOB_STATUS_DELETING },
+	{ LPQ_OFFLINE, JOB_STATUS_OFFLINE },
+	{ LPQ_PAPEROUT, JOB_STATUS_PAPEROUT },
+	{ LPQ_PRINTED, JOB_STATUS_PRINTED },
+	{ LPQ_DELETED, JOB_STATUS_DELETED },
+	{ LPQ_BLOCKED, JOB_STATUS_BLOCKED_DEVQ },
+	{ LPQ_USER_INTERVENTION, JOB_STATUS_USER_INTERVENTION },
+	{ (uint32_t)-1, 0 }
+};
+
+/* Convert a lpq status value stored in printing.tdb into the
+   appropriate win32 API constant. */
+
+static uint32_t map_to_spoolss_status(uint32_t lpq_status)
+{
+	int i = 0;
+
+	while (lpq_to_spoolss_status_map[i].lpq_status != -1) {
+		if (lpq_to_spoolss_status_map[i].lpq_status == lpq_status)
+			return lpq_to_spoolss_status_map[i].spoolss_status;
+		i++;
+	}
+
+	return 0;
+}
+
+/***************************************************************************
+ Append a jobid to a list
+***************************************************************************/
+
+static bool add_to_jobs_list(
+	struct tdb_print_db *pdb, uint32_t jobid, const char *key)
+{
+	uint8_t store_jobid[sizeof(uint32_t)];
+	TDB_DATA data = {
+		.dptr = store_jobid, .dsize = sizeof(store_jobid)
+	};
+	int ret;
+
+	SIVAL(&store_jobid, 0, jobid);
+
+	DBG_DEBUG("Added jobid %"PRIu32" to %s\n", jobid, key);
+
+	ret = tdb_append(pdb->tdb, string_tdb_data(key), data);
+	return ret == 0;
+}
+
+/***************************************************************************
+ Remove a jobid from the 'jobs changed' list.
+***************************************************************************/
+
+static bool remove_from_jobs_list(
+	const char *keystr, const char *sharename, uint32_t jobid)
+{
+	struct tdb_print_db *pdb = get_print_db_byname(sharename);
+	TDB_DATA data, key;
+	size_t job_count, i;
+	bool ret = False;
+	bool gotlock = False;
+
+	if (!pdb) {
+		return False;
+	}
+
+	ZERO_STRUCT(data);
+
+	key = string_tdb_data(keystr);
+
+	if (tdb_chainlock_with_timeout(pdb->tdb, key, 5) != 0)
+		goto out;
+
+	gotlock = True;
+
+	data = tdb_fetch(pdb->tdb, key);
+
+	if (data.dptr == NULL || data.dsize == 0 || (data.dsize % 4 != 0))
+		goto out;
+
+	job_count = data.dsize / 4;
+	for (i = 0; i < job_count; i++) {
+		uint32_t ch_jobid;
+
+		ch_jobid = IVAL(data.dptr, i*4);
+		if (ch_jobid == jobid) {
+			if (i < job_count -1 )
+				memmove(data.dptr + (i*4), data.dptr + (i*4) + 4, (job_count - i - 1)*4 );
+			data.dsize -= 4;
+			if (tdb_store(pdb->tdb, key, data, TDB_REPLACE) != 0)
+				goto out;
+			break;
+		}
+	}
+
+	ret = True;
+  out:
+
+	if (gotlock)
+		tdb_chainunlock(pdb->tdb, key);
+	SAFE_FREE(data.dptr);
+	release_print_db(pdb);
+	if (ret)
+		DBG_DEBUG("removed jobid %"PRIu32"\n", jobid);
+	else
+		DBG_DEBUG("Failed to remove jobid %"PRIu32"\n", jobid);
+	return ret;
+}
+
+static bool remove_from_jobs_changed(const char* sharename, uint32_t jobid)
+{
+	bool ret = remove_from_jobs_list(
+		"INFO/jobs_changed", sharename, jobid);
+	return ret;
+}
+
+static void pjob_store_notify(struct tevent_context *ev,
+			      struct messaging_context *msg_ctx,
+			      const char* sharename, uint32_t jobid,
+			      struct printjob *old_data,
+			      struct printjob *new_data,
+			      bool *pchanged)
+{
+	bool new_job = false;
+	bool changed = false;
+
+	if (old_data == NULL) {
+		new_job = true;
+	}
+
+	/* ACHTUNG!  Due to a bug in Samba's spoolss parsing of the
+	   NOTIFY_INFO_DATA buffer, we *have* to send the job submission
+	   time first or else we'll end up with potential alignment
+	   errors.  I don't think the systemtime should be spooled as
+	   a string, but this gets us around that error.
+	   --jerry (i'll feel dirty for this) */
+
+	if (new_job) {
+		notify_job_submitted(ev, msg_ctx,
+				     sharename, jobid, new_data->starttime);
+		notify_job_username(ev, msg_ctx,
+				    sharename, jobid, new_data->user);
+		notify_job_name(ev, msg_ctx,
+				sharename, jobid, new_data->jobname);
+		notify_job_status(ev, msg_ctx,
+				  sharename, jobid, map_to_spoolss_status(new_data->status));
+		notify_job_total_bytes(ev, msg_ctx,
+				       sharename, jobid, new_data->size);
+		notify_job_total_pages(ev, msg_ctx,
+				       sharename, jobid, new_data->page_count);
+	} else {
+		if (!strequal(old_data->jobname, new_data->jobname)) {
+			notify_job_name(ev, msg_ctx, sharename,
+					jobid, new_data->jobname);
+			changed = true;
+		}
+
+		if (old_data->status != new_data->status) {
+			notify_job_status(ev, msg_ctx,
+					  sharename, jobid,
+					  map_to_spoolss_status(new_data->status));
+		}
+
+		if (old_data->size != new_data->size) {
+			notify_job_total_bytes(ev, msg_ctx,
+					       sharename, jobid, new_data->size);
+		}
+
+		if (old_data->page_count != new_data->page_count) {
+			notify_job_total_pages(ev, msg_ctx,
+					       sharename, jobid,
+					       new_data->page_count);
+		}
+	}
+
+	*pchanged = changed;
+}
+
+/****************************************************************************
+ Store a job structure back to the database.
+****************************************************************************/
+
+static bool pjob_store(struct tevent_context *ev,
+		       struct messaging_context *msg_ctx,
+		       const char* sharename, uint32_t jobid,
+		       struct printjob *pjob)
+{
+	uint32_t tmp;
+	TDB_DATA 		old_data, new_data;
+	bool 			ret = False;
+	struct tdb_print_db 	*pdb = get_print_db_byname(sharename);
+	uint8_t			*buf = NULL;
+	int			len, newlen, buflen;
+
+
+	if (!pdb)
+		return False;
+
+	/* Get old data */
+
+	old_data = tdb_fetch(pdb->tdb, print_key(jobid, &tmp));
+
+	/* Doh!  Now we have to pack/unpack data since the NT_DEVICEMODE was added */
+
+	newlen = 0;
+
+	do {
+		len = 0;
+		buflen = newlen;
+		len += tdb_pack(buf+len, buflen-len, "ddddddddddfffff",
+				(uint32_t)pjob->pid,
+				(uint32_t)pjob->jobid,
+				(uint32_t)pjob->sysjob,
+				(uint32_t)pjob->fd,
+				(uint32_t)pjob->starttime,
+				(uint32_t)pjob->status,
+				(uint32_t)pjob->size,
+				(uint32_t)pjob->page_count,
+				(uint32_t)pjob->spooled,
+				(uint32_t)pjob->smbjob,
+				pjob->filename,
+				pjob->jobname,
+				pjob->user,
+				pjob->clientmachine,
+				pjob->queuename);
+
+		len += pack_devicemode(pjob->devmode, buf+len, buflen-len);
+
+		if (buflen != len) {
+			buf = (uint8_t *)SMB_REALLOC(buf, len);
+			if (!buf) {
+				DEBUG(0,("pjob_store: failed to enlarge buffer!\n"));
+				goto done;
+			}
+			newlen = len;
+		}
+	} while ( buflen != len );
+
+
+	/* Store new data */
+
+	new_data.dptr = buf;
+	new_data.dsize = len;
+	ret = (tdb_store(pdb->tdb, print_key(jobid, &tmp), new_data,
+			 TDB_REPLACE) == 0);
+
+	/* Send notify updates for what has changed */
+
+	if (ret) {
+		bool changed = false;
+		struct printjob old_pjob;
+
+		if (old_data.dsize) {
+			TALLOC_CTX *tmp_ctx = talloc_new(ev);
+			if (tmp_ctx == NULL)
+				goto done;
+
+			len = unpack_pjob(tmp_ctx, old_data.dptr,
+					  old_data.dsize, &old_pjob);
+			if (len != -1 ) {
+				pjob_store_notify(ev,
+						  msg_ctx,
+						  sharename, jobid, &old_pjob,
+						  pjob,
+						  &changed);
+				if (changed) {
+					add_to_jobs_list(
+						pdb,
+						jobid,
+						"INFO/jobs_changed");
+				}
+			}
+			talloc_free(tmp_ctx);
+
+		} else {
+			/* new job */
+			pjob_store_notify(ev, msg_ctx,
+					  sharename, jobid, NULL, pjob,
+					  &changed);
+		}
+	}
+
+done:
+	release_print_db(pdb);
+	SAFE_FREE( old_data.dptr );
+	SAFE_FREE( buf );
+
+	return ret;
+}
+
+/****************************************************************************
+ Remove a job structure from the database.
+****************************************************************************/
+
+static void pjob_delete(struct tevent_context *ev,
+			struct messaging_context *msg_ctx,
+			const char* sharename, uint32_t jobid)
+{
+	uint32_t tmp;
+	struct printjob *pjob;
+	uint32_t job_status = 0;
+	struct tdb_print_db *pdb;
+	TALLOC_CTX *tmp_ctx = talloc_new(ev);
+	if (tmp_ctx == NULL) {
+		return;
+	}
+
+	pdb = get_print_db_byname(sharename);
+	if (!pdb) {
+		goto err_out;
+	}
+
+	pjob = print_job_find(tmp_ctx, sharename, jobid);
+	if (!pjob) {
+		DEBUG(5, ("we were asked to delete nonexistent job %u\n",
+			  jobid));
+		goto err_release;
+	}
+
+	/* We must cycle through JOB_STATUS_DELETING and
+           JOB_STATUS_DELETED for the port monitor to delete the job
+           properly. */
+
+	job_status = JOB_STATUS_DELETING|JOB_STATUS_DELETED;
+	notify_job_status(ev, msg_ctx, sharename, jobid, job_status);
+
+	/* Remove from printing.tdb */
+
+	tdb_delete(pdb->tdb, print_key(jobid, &tmp));
+	remove_from_jobs_added(sharename, jobid);
+	rap_jobid_delete(sharename, jobid);
+err_release:
+	release_print_db(pdb);
+err_out:
+	talloc_free(tmp_ctx);
+}
+
+/****************************************************************************
+ List a unix job in the print database.
+****************************************************************************/
+
+static void print_unix_job(struct tevent_context *ev,
+			   struct messaging_context *msg_ctx,
+			   const char *sharename, print_queue_struct *q,
+			   uint32_t jobid)
+{
+	struct printjob pj, *old_pj;
+	TALLOC_CTX *tmp_ctx = talloc_new(ev);
+	if (tmp_ctx == NULL) {
+		return;
+	}
+
+	if (jobid == (uint32_t)-1) {
+		jobid = q->sysjob + UNIX_JOB_START;
+	}
+
+	/* Preserve the timestamp on an existing unix print job */
+
+	old_pj = print_job_find(tmp_ctx, sharename, jobid);
+
+	ZERO_STRUCT(pj);
+
+	pj.pid = (pid_t)-1;
+	pj.jobid = jobid;
+	pj.sysjob = q->sysjob;
+	pj.fd = -1;
+	pj.starttime = old_pj ? old_pj->starttime : q->time;
+	pj.status = q->status;
+	pj.size = q->size;
+	pj.spooled = True;
+	fstrcpy(pj.filename, old_pj ? old_pj->filename : "");
+	if (jobid < UNIX_JOB_START) {
+		pj.smbjob = True;
+		fstrcpy(pj.jobname, old_pj ? old_pj->jobname : "Remote Downlevel Document");
+	} else {
+		pj.smbjob = False;
+		fstrcpy(pj.jobname, old_pj ? old_pj->jobname : q->fs_file);
+	}
+	fstrcpy(pj.user, old_pj ? old_pj->user : q->fs_user);
+	fstrcpy(pj.queuename, old_pj ? old_pj->queuename : sharename );
+
+	pjob_store(ev, msg_ctx, sharename, jobid, &pj);
+	talloc_free(tmp_ctx);
+}
+
+
+struct traverse_struct {
+	print_queue_struct *queue;
+	size_t qcount, snum, maxcount, total_jobs;
+	const char *sharename;
+	time_t lpq_time;
+	const char *lprm_command;
+	struct printif *print_if;
+	struct tevent_context *ev;
+	struct messaging_context *msg_ctx;
+	TALLOC_CTX *mem_ctx;
+};
+
+/****************************************************************************
+ Utility fn to delete any jobs that are no longer active.
+****************************************************************************/
+
+static int traverse_fn_delete(TDB_CONTEXT *t, TDB_DATA key, TDB_DATA data, void *state)
+{
+	struct traverse_struct *ts = (struct traverse_struct *)state;
+	struct printjob pjob;
+	uint32_t jobid;
+	size_t i = 0;
+
+	if (  key.dsize != sizeof(jobid) )
+		return 0;
+
+	if (unpack_pjob(ts->mem_ctx, data.dptr, data.dsize, &pjob) == -1)
+		return 0;
+	talloc_free(pjob.devmode);
+	jobid = pjob.jobid;
+
+	if (!pjob.smbjob) {
+		/* remove a unix job if it isn't in the system queue any more */
+		for (i=0;i<ts->qcount;i++) {
+			if (ts->queue[i].sysjob == pjob.sysjob) {
+				break;
+			}
+		}
+		if (i == ts->qcount) {
+			DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !smbjob\n",
+						(unsigned int)jobid ));
+			pjob_delete(ts->ev, ts->msg_ctx,
+				    ts->sharename, jobid);
+			return 0;
+		}
+
+		/* need to continue the the bottom of the function to
+		   save the correct attributes */
+	}
+
+	/* maybe it hasn't been spooled yet */
+	if (!pjob.spooled) {
+		/* if a job is not spooled and the process doesn't
+                   exist then kill it. This cleans up after smbd
+                   deaths */
+		if (!process_exists_by_pid(pjob.pid)) {
+			DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !process_exists (%u)\n",
+						(unsigned int)jobid, (unsigned int)pjob.pid ));
+			pjob_delete(ts->ev, ts->msg_ctx,
+				    ts->sharename, jobid);
+		} else
+			ts->total_jobs++;
+		return 0;
+	}
+
+	/* this check only makes sense for jobs submitted from Windows clients */
+
+	if (pjob.smbjob) {
+		for (i=0;i<ts->qcount;i++) {
+			if ( pjob.status == LPQ_DELETED )
+				continue;
+
+			if (ts->queue[i].sysjob == pjob.sysjob) {
+
+				/* try to clean up any jobs that need to be deleted */
+
+				if ( pjob.status == LPQ_DELETING ) {
+					int result;
+
+					result = (*(ts->print_if->job_delete))(
+						ts->sharename, ts->lprm_command, &pjob );
+
+					if ( result != 0 ) {
+						/* if we can't delete, then reset the job status */
+						pjob.status = LPQ_QUEUED;
+						pjob_store(ts->ev, ts->msg_ctx,
+							   ts->sharename, jobid, &pjob);
+					}
+					else {
+						/* if we deleted the job, the remove the tdb record */
+						pjob_delete(ts->ev,
+							    ts->msg_ctx,
+							    ts->sharename, jobid);
+						pjob.status = LPQ_DELETED;
+					}
+
+				}
+
+				break;
+			}
+		}
+	}
+
+	/* The job isn't in the system queue - we have to assume it has
+	   completed, so delete the database entry. */
+
+	if (i == ts->qcount) {
+
+		/* A race can occur between the time a job is spooled and
+		   when it appears in the lpq output.  This happens when
+		   the job is added to printing.tdb when another smbd
+		   running print_queue_update() has completed a lpq and
+		   is currently traversing the printing tdb and deleting jobs.
+		   Don't delete the job if it was submitted after the lpq_time. */
+
+		if (pjob.starttime < ts->lpq_time) {
+			DEBUG(10,("traverse_fn_delete: pjob %u deleted due to pjob.starttime (%u) < ts->lpq_time (%u)\n",
+						(unsigned int)jobid,
+						(unsigned int)pjob.starttime,
+						(unsigned int)ts->lpq_time ));
+			pjob_delete(ts->ev, ts->msg_ctx,
+				    ts->sharename, jobid);
+		} else
+			ts->total_jobs++;
+		return 0;
+	}
+
+	/* Save the pjob attributes we will store. */
+	ts->queue[i].sysjob = pjob.sysjob;
+	ts->queue[i].size = pjob.size;
+	ts->queue[i].page_count = pjob.page_count;
+	ts->queue[i].status = pjob.status;
+	ts->queue[i].priority = 1;
+	ts->queue[i].time = pjob.starttime;
+	fstrcpy(ts->queue[i].fs_user, pjob.user);
+	fstrcpy(ts->queue[i].fs_file, pjob.jobname);
+
+	ts->total_jobs++;
+
+	return 0;
+}
+
+/****************************************************************************
+ Check if the print queue has been updated recently enough.
+****************************************************************************/
+
+static void print_cache_flush(const char *sharename)
+{
+	fstring key;
+	struct tdb_print_db *pdb = get_print_db_byname(sharename);
+
+	if (!pdb)
+		return;
+	slprintf(key, sizeof(key)-1, "CACHE/%s", sharename);
+	tdb_store_int32(pdb->tdb, key, -1);
+	release_print_db(pdb);
+}
+
+/****************************************************************************
+ Check if someone already thinks they are doing the update.
+****************************************************************************/
+
+static pid_t get_updating_pid(const char *sharename)
+{
+	fstring keystr;
+	TDB_DATA data, key;
+	pid_t updating_pid;
+	struct tdb_print_db *pdb = get_print_db_byname(sharename);
+
+	if (!pdb)
+		return (pid_t)-1;
+	slprintf(keystr, sizeof(keystr)-1, "UPDATING/%s", sharename);
+    	key = string_tdb_data(keystr);
+
+	data = tdb_fetch(pdb->tdb, key);
+	release_print_db(pdb);
+	if (!data.dptr || data.dsize != sizeof(pid_t)) {
+		SAFE_FREE(data.dptr);
+		return (pid_t)-1;
+	}
+
+	updating_pid = IVAL(data.dptr, 0);
+	SAFE_FREE(data.dptr);
+
+	if (process_exists_by_pid(updating_pid))
+		return updating_pid;
+
+	return (pid_t)-1;
+}
+
+/****************************************************************************
+ Set the fact that we're doing the update, or have finished doing the update
+ in the tdb.
+****************************************************************************/
+
+static void set_updating_pid(const fstring sharename, bool updating)
+{
+	fstring keystr;
+	TDB_DATA key;
+	TDB_DATA data;
+	pid_t updating_pid = getpid();
+	uint8_t buffer[4];
+
+	struct tdb_print_db *pdb = get_print_db_byname(sharename);
+
+	if (!pdb)
+		return;
+
+	slprintf(keystr, sizeof(keystr)-1, "UPDATING/%s", sharename);
+    	key = string_tdb_data(keystr);
+
+	DEBUG(5, ("set_updating_pid: %supdating lpq cache for print share %s\n",
+		updating ? "" : "not ",
+		sharename ));
+
+	if ( !updating ) {
+		tdb_delete(pdb->tdb, key);
+		release_print_db(pdb);
+		return;
+	}
+
+	SIVAL( buffer, 0, updating_pid);
+	data.dptr = buffer;
+	data.dsize = 4;		/* we always assume this is a 4 byte value */
+
+	tdb_store(pdb->tdb, key, data, TDB_REPLACE);
+	release_print_db(pdb);
+}
+
+/****************************************************************************
+ Sort print jobs by submittal time.
+****************************************************************************/
+
+static int printjob_comp(print_queue_struct *j1, print_queue_struct *j2)
+{
+	/* Silly cases */
+
+	if (!j1 && !j2)
+		return 0;
+	if (!j1)
+		return -1;
+	if (!j2)
+		return 1;
+
+	/* Sort on job start time */
+
+	if (j1->time == j2->time)
+		return 0;
+	return (j1->time > j2->time) ? 1 : -1;
+}
+
+/****************************************************************************
+ Store the sorted queue representation for later portmon retrieval.
+ Skip deleted jobs
+****************************************************************************/
+
+static void store_queue_struct(struct tdb_print_db *pdb, struct traverse_struct *pts)
+{
+	TDB_DATA data;
+	int max_reported_jobs = lp_max_reported_print_jobs(pts->snum);
+	print_queue_struct *queue = pts->queue;
+	size_t len;
+	size_t i;
+	unsigned int qcount;
+
+	if (max_reported_jobs && (max_reported_jobs < pts->qcount))
+		pts->qcount = max_reported_jobs;
+	qcount = 0;
+
+	/* Work out the size. */
+	data.dsize = 0;
+	data.dsize += tdb_pack(NULL, 0, "d", qcount);
+
+	for (i = 0; i < pts->qcount; i++) {
+		if ( queue[i].status == LPQ_DELETED )
+			continue;
+
+		qcount++;
+		data.dsize += tdb_pack(NULL, 0, "ddddddff",
+				(uint32_t)queue[i].sysjob,
+				(uint32_t)queue[i].size,
+				(uint32_t)queue[i].page_count,
+				(uint32_t)queue[i].status,
+				(uint32_t)queue[i].priority,
+				(uint32_t)queue[i].time,
+				queue[i].fs_user,
+				queue[i].fs_file);
+	}
+
+	if ((data.dptr = (uint8_t *)SMB_MALLOC(data.dsize)) == NULL)
+		return;
+
+        len = 0;
+	len += tdb_pack(data.dptr + len, data.dsize - len, "d", qcount);
+	for (i = 0; i < pts->qcount; i++) {
+		if ( queue[i].status == LPQ_DELETED )
+			continue;
+
+		len += tdb_pack(data.dptr + len, data.dsize - len, "ddddddff",
+				(uint32_t)queue[i].sysjob,
+				(uint32_t)queue[i].size,
+				(uint32_t)queue[i].page_count,
+				(uint32_t)queue[i].status,
+				(uint32_t)queue[i].priority,
+				(uint32_t)queue[i].time,
+				queue[i].fs_user,
+				queue[i].fs_file);
+	}
+
+	tdb_store(pdb->tdb, string_tdb_data("INFO/linear_queue_array"), data,
+		  TDB_REPLACE);
+	SAFE_FREE(data.dptr);
+	return;
+}
+
+static TDB_DATA get_jobs_added_data(struct tdb_print_db *pdb)
+{
+	TDB_DATA data;
+
+	ZERO_STRUCT(data);
+
+	data = tdb_fetch(pdb->tdb, string_tdb_data("INFO/jobs_added"));
+	if (data.dptr == NULL || data.dsize == 0 || (data.dsize % 4 != 0)) {
+		SAFE_FREE(data.dptr);
+		ZERO_STRUCT(data);
+	}
+
+	return data;
+}
+
+static void check_job_added(const char *sharename, TDB_DATA data, uint32_t jobid)
+{
+	unsigned int i;
+	unsigned int job_count = data.dsize / 4;
+
+	for (i = 0; i < job_count; i++) {
+		uint32_t ch_jobid;
+
+		ch_jobid = IVAL(data.dptr, i*4);
+		if (ch_jobid == jobid)
+			remove_from_jobs_added(sharename, jobid);
+	}
+}
+
+/****************************************************************************
+ Check if the print queue has been updated recently enough.
+****************************************************************************/
+
+static bool print_cache_expired(const char *sharename, bool check_pending)
+{
+	fstring key;
+	time_t last_qscan_time, time_now = time(NULL);
+	struct tdb_print_db *pdb = get_print_db_byname(sharename);
+	bool result = False;
+
+	if (!pdb)
+		return False;
+
+	snprintf(key, sizeof(key), "CACHE/%s", sharename);
+	last_qscan_time = (time_t)tdb_fetch_int32(pdb->tdb, key);
+
+	/*
+	 * Invalidate the queue for 3 reasons.
+	 * (1). last queue scan time == -1.
+	 * (2). Current time - last queue scan time > allowed cache time.
+	 * (3). last queue scan time > current time + MAX_CACHE_VALID_TIME (1 hour by default).
+	 * This last test picks up machines for which the clock has been moved
+	 * forward, an lpq scan done and then the clock moved back. Otherwise
+	 * that last lpq scan would stay around for a loooong loooong time... :-). JRA.
+	 */
+
+	if (last_qscan_time == ((time_t)-1)
+		|| (time_now - last_qscan_time) >= lp_lpq_cache_time()
+		|| last_qscan_time > (time_now + MAX_CACHE_VALID_TIME))
+	{
+		uint32_t u;
+		time_t msg_pending_time;
+
+		DEBUG(4, ("print_cache_expired: cache expired for queue %s "
+			"(last_qscan_time = %d, time now = %d, qcachetime = %d)\n",
+			sharename, (int)last_qscan_time, (int)time_now,
+			(int)lp_lpq_cache_time() ));
+
+		/* check if another smbd has already sent a message to update the
+		   queue.  Give the pending message one minute to clear and
+		   then send another message anyways.  Make sure to check for
+		   clocks that have been run forward and then back again. */
+
+		snprintf(key, sizeof(key), "MSG_PENDING/%s", sharename);
+
+		if ( check_pending
+			&& tdb_fetch_uint32( pdb->tdb, key, &u )
+			&& (msg_pending_time=u) > 0
+			&& msg_pending_time <= time_now
+			&& (time_now - msg_pending_time) < 60 )
+		{
+			DEBUG(4,("print_cache_expired: message already pending for %s.  Accepting cache\n",
+				sharename));
+			goto done;
+		}
+
+		result = True;
+	}
+
+done:
+	release_print_db(pdb);
+	return result;
+}
+
+/****************************************************************************
+ main work for updating the lpq cache for a printer queue
+****************************************************************************/
+
+static void print_queue_update_internal(struct tevent_context *ev,
+					struct messaging_context *msg_ctx,
+					const char *sharename,
+                                        struct printif *current_printif,
+                                        char *lpq_command, char *lprm_command)
+{
+	size_t i, qcount;
+	print_queue_struct *queue = NULL;
+	print_status_struct status;
+	print_status_struct old_status;
+	struct printjob *pjob;
+	struct traverse_struct tstruct;
+	TDB_DATA data, key;
+	TDB_DATA jcdata;
+	fstring keystr, cachestr;
+	struct tdb_print_db *pdb = get_print_db_byname(sharename);
+	TALLOC_CTX *tmp_ctx = talloc_new(ev);
+
+	if ((pdb == NULL) || (tmp_ctx == NULL)) {
+		return;
+	}
+
+	DEBUG(5,("print_queue_update_internal: printer = %s, type = %d, lpq command = [%s]\n",
+		sharename, current_printif->type, lpq_command));
+
+	/*
+	 * Update the cache time FIRST ! Stops others even
+	 * attempting to get the lock and doing this
+	 * if the lpq takes a long time.
+	 */
+
+	slprintf(cachestr, sizeof(cachestr)-1, "CACHE/%s", sharename);
+	tdb_store_int32(pdb->tdb, cachestr, (int)time(NULL));
+
+        /* get the current queue using the appropriate interface */
+	ZERO_STRUCT(status);
+
+	qcount = (*(current_printif->queue_get))(sharename,
+		current_printif->type,
+		lpq_command, &queue, &status);
+
+	DBG_NOTICE("%zu job%s in queue for %s\n",
+		   qcount,
+		   (qcount != 1) ? "s" : "",
+		   sharename);
+
+	/* Sort the queue by submission time otherwise they are displayed
+	   in hash order. */
+
+	TYPESAFE_QSORT(queue, qcount, printjob_comp);
+
+	/*
+	  any job in the internal database that is marked as spooled
+	  and doesn't exist in the system queue is considered finished
+	  and removed from the database
+
+	  any job in the system database but not in the internal database
+	  is added as a unix job
+
+	  fill in any system job numbers as we go
+	*/
+	jcdata = get_jobs_added_data(pdb);
+
+	for (i=0; i<qcount; i++) {
+		uint32_t jobid = sysjob_to_jobid_pdb(pdb, queue[i].sysjob);
+		if (jobid == (uint32_t)-1) {
+			/* assume its a unix print job */
+			print_unix_job(ev, msg_ctx,
+				       sharename, &queue[i], jobid);
+			continue;
+		}
+
+		/* we have an active SMB print job - update its status */
+		pjob = print_job_find(tmp_ctx, sharename, jobid);
+		if (!pjob) {
+			/* err, somethings wrong. Probably smbd was restarted
+			   with jobs in the queue. All we can do is treat them
+			   like unix jobs. Pity. */
+			DEBUG(1, ("queued print job %d not found in jobs list, "
+				  "assuming unix job\n", jobid));
+			print_unix_job(ev, msg_ctx,
+				       sharename, &queue[i], jobid);
+			continue;
+		}
+
+		/* don't reset the status on jobs to be deleted */
+
+		if ( pjob->status != LPQ_DELETING )
+			pjob->status = queue[i].status;
+
+		pjob_store(ev, msg_ctx, sharename, jobid, pjob);
+
+		check_job_added(sharename, jcdata, jobid);
+	}
+
+	SAFE_FREE(jcdata.dptr);
+
+	/* now delete any queued entries that don't appear in the
+           system queue */
+	tstruct.queue = queue;
+	tstruct.qcount = qcount;
+	tstruct.snum = -1;
+	tstruct.total_jobs = 0;
+	tstruct.lpq_time = time(NULL);
+	tstruct.sharename = sharename;
+	tstruct.lprm_command = lprm_command;
+	tstruct.print_if = current_printif;
+	tstruct.ev = ev;
+	tstruct.msg_ctx = msg_ctx;
+	tstruct.mem_ctx = tmp_ctx;
+
+	tdb_traverse(pdb->tdb, traverse_fn_delete, (void *)&tstruct);
+
+	/* Store the linearised queue, max jobs only. */
+	store_queue_struct(pdb, &tstruct);
+
+	SAFE_FREE(tstruct.queue);
+	talloc_free(tmp_ctx);
+
+	DBG_DEBUG("printer %s INFO, total_jobs = %zu\n",
+		  sharename,
+		  tstruct.total_jobs);
+
+	tdb_store_int32(pdb->tdb, "INFO/total_jobs", tstruct.total_jobs);
+
+	get_queue_status(sharename, &old_status);
+	if (old_status.qcount != qcount) {
+		DBG_DEBUG("Queue status change %zu jobs -> %zu jobs "
+			  "for printer %s\n",
+			  old_status.qcount,
+			  qcount,
+			  sharename);
+	}
+
+	/* store the new queue status structure */
+	slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", sharename);
+	key = string_tdb_data(keystr);
+
+	status.qcount = qcount;
+	data.dptr = (uint8_t *)&status;
+	data.dsize = sizeof(status);
+	tdb_store(pdb->tdb, key, data, TDB_REPLACE);
+
+	/*
+	 * Update the cache time again. We want to do this call
+	 * as little as possible...
+	 */
+
+	slprintf(keystr, sizeof(keystr)-1, "CACHE/%s", sharename);
+	tdb_store_int32(pdb->tdb, keystr, (int32_t)time(NULL));
+
+	/* clear the msg pending record for this queue */
+
+	snprintf(keystr, sizeof(keystr), "MSG_PENDING/%s", sharename);
+
+	if ( !tdb_store_uint32( pdb->tdb, keystr, 0 ) ) {
+		/* log a message but continue on */
+
+		DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
+			sharename));
+	}
+
+	release_print_db( pdb );
+
+	return;
+}
+
+/****************************************************************************
+ Update the internal database from the system print queue for a queue.
+ obtain a lock on the print queue before proceeding (needed when mutiple
+ smbd processes maytry to update the lpq cache concurrently).
+****************************************************************************/
+
+static void print_queue_update_with_lock( struct tevent_context *ev,
+					  struct messaging_context *msg_ctx,
+					  const char *sharename,
+                                          struct printif *current_printif,
+                                          char *lpq_command, char *lprm_command )
+{
+	fstring keystr;
+	struct tdb_print_db *pdb;
+
+	DEBUG(5,("print_queue_update_with_lock: printer share = %s\n", sharename));
+	pdb = get_print_db_byname(sharename);
+	if (!pdb)
+		return;
+
+	if ( !print_cache_expired(sharename, False) ) {
+		DEBUG(5,("print_queue_update_with_lock: print cache for %s is still ok\n", sharename));
+		release_print_db(pdb);
+		return;
+	}
+
+	/*
+	 * Check to see if someone else is doing this update.
+	 * This is essentially a mutex on the update.
+	 */
+
+	if (get_updating_pid(sharename) != -1) {
+		release_print_db(pdb);
+		return;
+	}
+
+	/* Lock the queue for the database update */
+
+	slprintf(keystr, sizeof(keystr) - 1, "LOCK/%s", sharename);
+	/* Only wait 10 seconds for this. */
+	if (tdb_lock_bystring_with_timeout(pdb->tdb, keystr, 10) != 0) {
+		DEBUG(0,("print_queue_update_with_lock: Failed to lock printer %s database\n", sharename));
+		release_print_db(pdb);
+		return;
+	}
+
+	/*
+	 * Ensure that no one else got in here.
+	 * If the updating pid is still -1 then we are
+	 * the winner.
+	 */
+
+	if (get_updating_pid(sharename) != -1) {
+		/*
+		 * Someone else is doing the update, exit.
+		 */
+		tdb_unlock_bystring(pdb->tdb, keystr);
+		release_print_db(pdb);
+		return;
+	}
+
+	/*
+	 * We're going to do the update ourselves.
+	 */
+
+	/* Tell others we're doing the update. */
+	set_updating_pid(sharename, True);
+
+	/*
+	 * Allow others to enter and notice we're doing
+	 * the update.
+	 */
+
+	tdb_unlock_bystring(pdb->tdb, keystr);
+
+	/* do the main work now */
+
+	print_queue_update_internal(ev, msg_ctx,
+				    sharename, current_printif,
+				    lpq_command, lprm_command);
+
+	/* Delete our pid from the db. */
+	set_updating_pid(sharename, False);
+	release_print_db(pdb);
+}
+
+/****************************************************************************
+this is the receive function of the background lpq updater
+****************************************************************************/
+void print_queue_receive(struct messaging_context *msg,
+				void *private_data,
+				uint32_t msg_type,
+				struct server_id server_id,
+				DATA_BLOB *data)
+{
+	fstring sharename;
+	char *lpqcommand = NULL, *lprmcommand = NULL;
+	int printing_type;
+	size_t len;
+
+	len = tdb_unpack( (uint8_t *)data->data, data->length, "fdPP",
+		sharename,
+		&printing_type,
+		&lpqcommand,
+		&lprmcommand );
+
+	if ( len == -1 ) {
+		SAFE_FREE(lpqcommand);
+		SAFE_FREE(lprmcommand);
+		DEBUG(0,("print_queue_receive: Got invalid print queue update message\n"));
+		return;
+	}
+
+	print_queue_update_with_lock(global_event_context(), msg, sharename,
+		get_printer_fns_from_type((enum printing_types)printing_type),
+		lpqcommand, lprmcommand );
+
+	SAFE_FREE(lpqcommand);
+	SAFE_FREE(lprmcommand);
+	return;
+}
+
+/****************************************************************************
+update the internal database from the system print queue for a queue
+****************************************************************************/
+
+static void print_queue_update(struct messaging_context *msg_ctx,
+			       int snum, bool force)
+{
+	char key[268];
+	fstring sharename;
+	char *lpqcommand = NULL;
+	char *lprmcommand = NULL;
+	uint8_t *buffer = NULL;
+	size_t len = 0;
+	size_t newlen;
+	struct tdb_print_db *pdb;
+	int type;
+	struct printif *current_printif;
+	TALLOC_CTX *ctx = talloc_tos();
+	const struct loadparm_substitution *lp_sub =
+		loadparm_s3_global_substitution();
+
+	fstrcpy( sharename, lp_const_servicename(snum));
+
+	/* don't strip out characters like '$' from the printername */
+
+	lpqcommand = talloc_string_sub2(ctx,
+			lp_lpq_command(snum),
+			"%p",
+			lp_printername(talloc_tos(), lp_sub, snum),
+			false, false, false);
+	if (!lpqcommand) {
+		return;
+	}
+	lpqcommand = talloc_sub_full(ctx,
+			lp_servicename(talloc_tos(), lp_sub, snum),
+			current_user_info.unix_name,
+			"",
+			get_current_gid(NULL),
+			get_current_username(),
+			current_user_info.domain,
+			lpqcommand);
+	if (!lpqcommand) {
+		return;
+	}
+
+	lprmcommand = talloc_string_sub2(ctx,
+			lp_lprm_command(snum),
+			"%p",
+			lp_printername(talloc_tos(), lp_sub, snum),
+			false, false, false);
+	if (!lprmcommand) {
+		return;
+	}
+	lprmcommand = talloc_sub_full(ctx,
+			lp_servicename(talloc_tos(), lp_sub, snum),
+			current_user_info.unix_name,
+			"",
+			get_current_gid(NULL),
+			get_current_username(),
+			current_user_info.domain,
+			lprmcommand);
+	if (!lprmcommand) {
+		return;
+	}
+
+	/*
+	 * Make sure that the background queue process exists.
+	 * Otherwise just do the update ourselves
+	 */
+
+	if ( force || background_lpq_updater_pid == -1 ) {
+		DEBUG(4,("print_queue_update: updating queue [%s] myself\n", sharename));
+		current_printif = get_printer_fns( snum );
+		print_queue_update_with_lock(global_event_context(), msg_ctx,
+					     sharename, current_printif,
+					     lpqcommand, lprmcommand);
+
+		return;
+	}
+
+	type = lp_printing(snum);
+
+	/* get the length */
+
+	len = tdb_pack( NULL, 0, "fdPP",
+		sharename,
+		type,
+		lpqcommand,
+		lprmcommand );
+
+	buffer = SMB_XMALLOC_ARRAY( uint8_t, len );
+
+	/* now pack the buffer */
+	newlen = tdb_pack( buffer, len, "fdPP",
+		sharename,
+		type,
+		lpqcommand,
+		lprmcommand );
+
+	SMB_ASSERT( newlen == len );
+
+	DEBUG(10,("print_queue_update: Sending message -> printer = %s, "
+		"type = %d, lpq command = [%s] lprm command = [%s]\n",
+		sharename, type, lpqcommand, lprmcommand ));
+
+	/* here we set a msg pending record for other smbd processes
+	   to throttle the number of duplicate print_queue_update msgs
+	   sent.  */
+
+	pdb = get_print_db_byname(sharename);
+	if (!pdb) {
+		SAFE_FREE(buffer);
+		return;
+	}
+
+	snprintf(key, sizeof(key), "MSG_PENDING/%s", sharename);
+
+	if ( !tdb_store_uint32( pdb->tdb, key, time(NULL) ) ) {
+		/* log a message but continue on */
+
+		DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
+			sharename));
+	}
+
+	release_print_db( pdb );
+
+	/* finally send the message */
+
+	send_to_bgqd(msg_ctx, MSG_PRINTER_UPDATE, (uint8_t *)buffer, len);
+
+	SAFE_FREE( buffer );
+
+	return;
+}
+
+/****************************************************************************
+ Create/Update an entry in the print tdb that will allow us to send notify
+ updates only to interested smbd's.
+****************************************************************************/
+
+bool print_notify_register_pid(int snum)
+{
+	TDB_DATA data;
+	struct tdb_print_db *pdb = NULL;
+	TDB_CONTEXT *tdb = NULL;
+	const char *printername;
+	uint32_t mypid = (uint32_t)getpid();
+	bool ret = False;
+	size_t i;
+
+	/* if (snum == -1), then the change notify request was
+	   on a print server handle and we need to register on
+	   all print queus */
+
+	if (snum == -1)
+	{
+		int num_services = lp_numservices();
+		int idx;
+
+		for ( idx=0; idx<num_services; idx++ ) {
+			if (lp_snum_ok(idx) && lp_printable(idx) )
+				print_notify_register_pid(idx);
+		}
+
+		return True;
+	}
+	else /* register for a specific printer */
+	{
+		printername = lp_const_servicename(snum);
+		pdb = get_print_db_byname(printername);
+		if (!pdb)
+			return False;
+		tdb = pdb->tdb;
+	}
+
+	if (tdb_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) != 0) {
+		DEBUG(0,("print_notify_register_pid: Failed to lock printer %s\n",
+					printername));
+		if (pdb)
+			release_print_db(pdb);
+		return False;
+	}
+
+	data = get_printer_notify_pid_list( tdb, printername, True );
+
+	/* Add ourselves and increase the refcount. */
+
+	for (i = 0; i < data.dsize; i += 8) {
+		if (IVAL(data.dptr,i) == mypid) {
+			uint32_t new_refcount = IVAL(data.dptr, i+4) + 1;
+			SIVAL(data.dptr, i+4, new_refcount);
+			break;
+		}
+	}
+
+	if (i == data.dsize) {
+		/* We weren't in the list. Realloc. */
+		data.dptr = (uint8_t *)SMB_REALLOC(data.dptr, data.dsize + 8);
+		if (!data.dptr) {
+			DEBUG(0,("print_notify_register_pid: Relloc fail for printer %s\n",
+						printername));
+			goto done;
+		}
+		data.dsize += 8;
+		SIVAL(data.dptr,data.dsize - 8,mypid);
+		SIVAL(data.dptr,data.dsize - 4,1); /* Refcount. */
+	}
+
+	/* Store back the record. */
+	if (tdb_store_bystring(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) != 0) {
+		DEBUG(0,("print_notify_register_pid: Failed to update pid \
+list for printer %s\n", printername));
+		goto done;
+	}
+
+	ret = True;
+
+ done:
+
+	tdb_unlock_bystring(tdb, NOTIFY_PID_LIST_KEY);
+	if (pdb)
+		release_print_db(pdb);
+	SAFE_FREE(data.dptr);
+	return ret;
+}
+
+/****************************************************************************
+ Update an entry in the print tdb that will allow us to send notify
+ updates only to interested smbd's.
+****************************************************************************/
+
+bool print_notify_deregister_pid(int snum)
+{
+	TDB_DATA data;
+	struct tdb_print_db *pdb = NULL;
+	TDB_CONTEXT *tdb = NULL;
+	const char *printername;
+	uint32_t mypid = (uint32_t)getpid();
+	size_t i;
+	bool ret = False;
+
+	/* if ( snum == -1 ), we are deregister a print server handle
+	   which means to deregister on all print queues */
+
+	if (snum == -1)
+	{
+		int num_services = lp_numservices();
+		int idx;
+
+		for ( idx=0; idx<num_services; idx++ ) {
+			if ( lp_snum_ok(idx) && lp_printable(idx) )
+				print_notify_deregister_pid(idx);
+		}
+
+		return True;
+	}
+	else /* deregister a specific printer */
+	{
+		printername = lp_const_servicename(snum);
+		pdb = get_print_db_byname(printername);
+		if (!pdb)
+			return False;
+		tdb = pdb->tdb;
+	}
+
+	if (tdb_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) != 0) {
+		DEBUG(0,("print_notify_register_pid: Failed to lock \
+printer %s database\n", printername));
+		if (pdb)
+			release_print_db(pdb);
+		return False;
+	}
+
+	data = get_printer_notify_pid_list( tdb, printername, True );
+
+	/* Reduce refcount. Remove ourselves if zero. */
+
+	for (i = 0; i < data.dsize; ) {
+		if (IVAL(data.dptr,i) == mypid) {
+			uint32_t refcount = IVAL(data.dptr, i+4);
+
+			refcount--;
+
+			if (refcount == 0) {
+				if (data.dsize - i > 8)
+					memmove( &data.dptr[i], &data.dptr[i+8], data.dsize - i - 8);
+				data.dsize -= 8;
+				continue;
+			}
+			SIVAL(data.dptr, i+4, refcount);
+		}
+
+		i += 8;
+	}
+
+	if (data.dsize == 0)
+		SAFE_FREE(data.dptr);
+
+	/* Store back the record. */
+	if (tdb_store_bystring(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) != 0) {
+		DEBUG(0,("print_notify_register_pid: Failed to update pid \
+list for printer %s\n", printername));
+		goto done;
+	}
+
+	ret = True;
+
+  done:
+
+	tdb_unlock_bystring(tdb, NOTIFY_PID_LIST_KEY);
+	if (pdb)
+		release_print_db(pdb);
+	SAFE_FREE(data.dptr);
+	return ret;
+}
+
+/****************************************************************************
+ Check if a jobid is valid. It is valid if it exists in the database.
+****************************************************************************/
+
+bool print_job_exists(const char* sharename, uint32_t jobid)
+{
+	struct tdb_print_db *pdb = get_print_db_byname(sharename);
+	bool ret;
+	uint32_t tmp;
+
+	if (!pdb)
+		return False;
+	ret = tdb_exists(pdb->tdb, print_key(jobid, &tmp));
+	release_print_db(pdb);
+	return ret;
+}
+
+/****************************************************************************
+ Return the device mode asigned to a specific print job.
+ Only valid for the process doing the spooling and when the job
+ has not been spooled.
+****************************************************************************/
+
+struct spoolss_DeviceMode *print_job_devmode(TALLOC_CTX *mem_ctx,
+					     const char *sharename,
+					     uint32_t jobid)
+{
+	struct printjob *pjob = print_job_find(mem_ctx, sharename, jobid);
+	if (pjob == NULL) {
+		return NULL;
+	}
+
+	return pjob->devmode;
+}
+
+/****************************************************************************
+ Set the name of a job. Only possible for owner.
+****************************************************************************/
+
+bool print_job_set_name(struct tevent_context *ev,
+			struct messaging_context *msg_ctx,
+			const char *sharename, uint32_t jobid, const char *name)
+{
+	struct printjob *pjob;
+	bool ret;
+	TALLOC_CTX *tmp_ctx = talloc_new(ev);
+	if (tmp_ctx == NULL) {
+		return false;
+	}
+
+	pjob = print_job_find(tmp_ctx, sharename, jobid);
+	if (!pjob || pjob->pid != getpid()) {
+		ret = false;
+		goto err_out;
+	}
+
+	fstrcpy(pjob->jobname, name);
+	ret = pjob_store(ev, msg_ctx, sharename, jobid, pjob);
+err_out:
+	talloc_free(tmp_ctx);
+	return ret;
+}
+
+/****************************************************************************
+ Get the name of a job. Only possible for owner.
+****************************************************************************/
+
+bool print_job_get_name(TALLOC_CTX *mem_ctx, const char *sharename, uint32_t jobid, char **name)
+{
+	struct printjob *pjob;
+
+	pjob = print_job_find(mem_ctx, sharename, jobid);
+	if (!pjob || pjob->pid != getpid()) {
+		return false;
+	}
+
+	*name = pjob->jobname;
+	return true;
+}
+
+
+/***************************************************************************
+ Remove a jobid from the 'jobs added' list.
+***************************************************************************/
+
+static bool remove_from_jobs_added(const char* sharename, uint32_t jobid)
+{
+	bool ret = remove_from_jobs_list("INFO/jobs_added", sharename, jobid);
+	return ret;
+}
+
+/****************************************************************************
+ Delete a print job - don't update queue.
+****************************************************************************/
+
+static bool print_job_delete1(struct tevent_context *ev,
+			      struct messaging_context *msg_ctx,
+			      int snum, uint32_t jobid)
+{
+	const char* sharename = lp_const_servicename(snum);
+	const struct loadparm_substitution *lp_sub =
+		loadparm_s3_global_substitution();
+	struct printjob *pjob;
+	int result = 0;
+	struct printif *current_printif = get_printer_fns( snum );
+	bool ret;
+	TALLOC_CTX *tmp_ctx = talloc_new(ev);
+	if (tmp_ctx == NULL) {
+		return false;
+	}
+
+	pjob = print_job_find(tmp_ctx, sharename, jobid);
+	if (!pjob) {
+		ret = false;
+		goto err_out;
+	}
+
+	/*
+	 * If already deleting just return.
+	 */
+
+	if (pjob->status == LPQ_DELETING) {
+		ret = true;
+		goto err_out;
+	}
+
+	/* Hrm - we need to be able to cope with deleting a job before it
+	   has reached the spooler.  Just mark it as LPQ_DELETING and
+	   let the print_queue_update() code rmeove the record */
+
+
+	if (pjob->sysjob == -1) {
+		DEBUG(5, ("attempt to delete job %u not seen by lpr\n", (unsigned int)jobid));
+	}
+
+	/* Set the tdb entry to be deleting. */
+
+	pjob->status = LPQ_DELETING;
+	pjob_store(ev, msg_ctx, sharename, jobid, pjob);
+
+	if (pjob->spooled && pjob->sysjob != -1)
+	{
+		result = (*(current_printif->job_delete))(
+			lp_printername(talloc_tos(), lp_sub, snum),
+			lp_lprm_command(snum),
+			pjob);
+
+		/* Delete the tdb entry if the delete succeeded or the job hasn't
+		   been spooled. */
+
+		if (result == 0) {
+			struct tdb_print_db *pdb = get_print_db_byname(sharename);
+			int njobs = 1;
+
+			if (!pdb) {
+				ret = false;
+				goto err_out;
+			}
+			pjob_delete(ev, msg_ctx, sharename, jobid);
+			/* Ensure we keep a rough count of the number of total jobs... */
+			tdb_change_int32_atomic(pdb->tdb, "INFO/total_jobs", &njobs, -1);
+			release_print_db(pdb);
+		}
+	}
+
+	remove_from_jobs_added( sharename, jobid );
+
+	ret = (result == 0);
+err_out:
+	talloc_free(tmp_ctx);
+	return ret;
+}
+
+/****************************************************************************
+ Return true if the current user owns the print job.
+****************************************************************************/
+
+static bool is_owner(const struct auth_session_info *server_info,
+		     const char *servicename,
+		     uint32_t jobid)
+{
+	struct printjob *pjob;
+	bool ret;
+	TALLOC_CTX *tmp_ctx = talloc_new(server_info);
+	if (tmp_ctx == NULL) {
+		return false;
+	}
+
+	pjob = print_job_find(tmp_ctx, servicename, jobid);
+	if (!pjob || !server_info) {
+		ret = false;
+		goto err_out;
+	}
+
+	ret = strequal(pjob->user, server_info->unix_info->sanitized_username);
+err_out:
+	talloc_free(tmp_ctx);
+	return ret;
+}
+
+/****************************************************************************
+ Delete a print job.
+****************************************************************************/
+
+WERROR print_job_delete(const struct auth_session_info *server_info,
+			struct messaging_context *msg_ctx,
+			int snum, uint32_t jobid)
+{
+	const char* sharename = lp_const_servicename(snum);
+	const struct loadparm_substitution *lp_sub =
+		loadparm_s3_global_substitution();
+	struct printjob *pjob;
+	bool 	owner;
+	WERROR werr;
+	TALLOC_CTX *tmp_ctx = talloc_new(msg_ctx);
+	if (tmp_ctx == NULL) {
+		return WERR_NOT_ENOUGH_MEMORY;
+	}
+
+	owner = is_owner(server_info, lp_const_servicename(snum), jobid);
+
+	/* Check access against security descriptor or whether the user
+	   owns their job. */
+
+	if (!owner &&
+	    !W_ERROR_IS_OK(print_access_check(server_info, msg_ctx, snum,
+					      JOB_ACCESS_ADMINISTER))) {
+		DEBUG(0, ("print job delete denied."
+			  "User name: %s, Printer name: %s.",
+			  uidtoname(server_info->unix_token->uid),
+			  lp_printername(tmp_ctx, lp_sub, snum)));
+
+		werr = WERR_ACCESS_DENIED;
+		goto err_out;
+	}
+
+	/*
+	 * get the spooled filename of the print job
+	 * if this works, then the file has not been spooled
+	 * to the underlying print system.  Just delete the
+	 * spool file & return.
+	 */
+
+	pjob = print_job_find(tmp_ctx, sharename, jobid);
+	if (!pjob || pjob->spooled || pjob->pid != getpid()) {
+		DEBUG(10, ("Skipping spool file removal for job %u\n", jobid));
+	} else {
+		DEBUG(10, ("Removing spool file [%s]\n", pjob->filename));
+		if (unlink(pjob->filename) == -1) {
+			werr = map_werror_from_unix(errno);
+			goto err_out;
+		}
+	}
+
+	if (!print_job_delete1(global_event_context(), msg_ctx, snum, jobid)) {
+		werr = WERR_ACCESS_DENIED;
+		goto err_out;
+	}
+
+	/* force update the database and say the delete failed if the
+           job still exists */
+
+	print_queue_update(msg_ctx, snum, True);
+
+	pjob = print_job_find(tmp_ctx, sharename, jobid);
+	if (pjob && (pjob->status != LPQ_DELETING)) {
+		werr = WERR_ACCESS_DENIED;
+		goto err_out;
+	}
+	werr = WERR_PRINTER_HAS_JOBS_QUEUED;
+
+err_out:
+	talloc_free(tmp_ctx);
+	return werr;
+}
+
+/****************************************************************************
+ Pause a job.
+****************************************************************************/
+
+WERROR print_job_pause(const struct auth_session_info *server_info,
+		     struct messaging_context *msg_ctx,
+		     int snum, uint32_t jobid)
+{
+	const char* sharename = lp_const_servicename(snum);
+	const struct loadparm_substitution *lp_sub =
+		loadparm_s3_global_substitution();
+	struct printjob *pjob;
+	int ret = -1;
+	struct printif *current_printif = get_printer_fns( snum );
+	WERROR werr;
+	TALLOC_CTX *tmp_ctx = talloc_new(msg_ctx);
+	if (tmp_ctx == NULL) {
+		return WERR_NOT_ENOUGH_MEMORY;
+	}
+
+	pjob = print_job_find(tmp_ctx, sharename, jobid);
+	if (!pjob || !server_info) {
+		DEBUG(10, ("print_job_pause: no pjob or user for jobid %u\n",
+			(unsigned int)jobid ));
+		werr = WERR_INVALID_PARAMETER;
+		goto err_out;
+	}
+
+	if (!pjob->spooled || pjob->sysjob == -1) {
+		DEBUG(10, ("print_job_pause: not spooled or bad sysjob = %d for jobid %u\n",
+			(int)pjob->sysjob, (unsigned int)jobid ));
+		werr = WERR_INVALID_PARAMETER;
+		goto err_out;
+	}
+
+	if (!is_owner(server_info, lp_const_servicename(snum), jobid) &&
+	    !W_ERROR_IS_OK(print_access_check(server_info, msg_ctx, snum,
+					      JOB_ACCESS_ADMINISTER))) {
+		DEBUG(0, ("print job pause denied."
+			  "User name: %s, Printer name: %s.",
+			  uidtoname(server_info->unix_token->uid),
+			  lp_printername(tmp_ctx, lp_sub, snum)));
+
+		werr = WERR_ACCESS_DENIED;
+		goto err_out;
+	}
+
+	/* need to pause the spooled entry */
+	ret = (*(current_printif->job_pause))(snum, pjob);
+
+	if (ret != 0) {
+		werr = WERR_INVALID_PARAMETER;
+		goto err_out;
+	}
+
+	/* force update the database */
+	print_cache_flush(lp_const_servicename(snum));
+
+	/* Send a printer notify message */
+
+	notify_job_status(global_event_context(), msg_ctx, sharename, jobid,
+			  JOB_STATUS_PAUSED);
+
+	/* how do we tell if this succeeded? */
+	werr = WERR_OK;
+err_out:
+	talloc_free(tmp_ctx);
+	return werr;
+}
+
+/****************************************************************************
+ Resume a job.
+****************************************************************************/
+
+WERROR print_job_resume(const struct auth_session_info *server_info,
+		      struct messaging_context *msg_ctx,
+		      int snum, uint32_t jobid)
+{
+	const char *sharename = lp_const_servicename(snum);
+	const struct loadparm_substitution *lp_sub =
+		loadparm_s3_global_substitution();
+	struct printjob *pjob;
+	int ret;
+	struct printif *current_printif = get_printer_fns( snum );
+	WERROR werr;
+	TALLOC_CTX *tmp_ctx = talloc_new(msg_ctx);
+	if (tmp_ctx == NULL)
+		return WERR_NOT_ENOUGH_MEMORY;
+
+	pjob = print_job_find(tmp_ctx, sharename, jobid);
+	if (!pjob || !server_info) {
+		DEBUG(10, ("print_job_resume: no pjob or user for jobid %u\n",
+			(unsigned int)jobid ));
+		werr = WERR_INVALID_PARAMETER;
+		goto err_out;
+	}
+
+	if (!pjob->spooled || pjob->sysjob == -1) {
+		DEBUG(10, ("print_job_resume: not spooled or bad sysjob = %d for jobid %u\n",
+			(int)pjob->sysjob, (unsigned int)jobid ));
+		werr = WERR_INVALID_PARAMETER;
+		goto err_out;
+	}
+
+	if (!is_owner(server_info, lp_const_servicename(snum), jobid) &&
+	    !W_ERROR_IS_OK(print_access_check(server_info, msg_ctx, snum,
+					      JOB_ACCESS_ADMINISTER))) {
+		DEBUG(0, ("print job resume denied."
+			  "User name: %s, Printer name: %s.",
+			  uidtoname(server_info->unix_token->uid),
+			  lp_printername(tmp_ctx, lp_sub, snum)));
+
+		werr = WERR_ACCESS_DENIED;
+		goto err_out;
+	}
+
+	ret = (*(current_printif->job_resume))(snum, pjob);
+
+	if (ret != 0) {
+		werr = WERR_INVALID_PARAMETER;
+		goto err_out;
+	}
+
+	/* force update the database */
+	print_cache_flush(lp_const_servicename(snum));
+
+	/* Send a printer notify message */
+
+	notify_job_status(global_event_context(), msg_ctx, sharename, jobid,
+			  JOB_STATUS_QUEUED);
+
+	werr = WERR_OK;
+err_out:
+	talloc_free(tmp_ctx);
+	return werr;
+}
+
+/****************************************************************************
+ Write to a print file.
+****************************************************************************/
+
+ssize_t print_job_write(struct tevent_context *ev,
+			struct messaging_context *msg_ctx,
+			int snum, uint32_t jobid, const char *buf, size_t size)
+{
+	const char* sharename = lp_const_servicename(snum);
+	ssize_t return_code;
+	struct printjob *pjob;
+	TALLOC_CTX *tmp_ctx = talloc_new(ev);
+	if (tmp_ctx == NULL) {
+		return -1;
+	}
+
+	pjob = print_job_find(tmp_ctx, sharename, jobid);
+	if (!pjob) {
+		return_code = -1;
+		goto err_out;
+	}
+
+	/* don't allow another process to get this info - it is meaningless */
+	if (pjob->pid != getpid()) {
+		return_code = -1;
+		goto err_out;
+	}
+
+	/* if SMBD is spooling this can't be allowed */
+	if (pjob->status == PJOB_SMBD_SPOOLING) {
+		return_code = -1;
+		goto err_out;
+	}
+
+	return_code = write_data(pjob->fd, buf, size);
+	if (return_code > 0) {
+		pjob->size += size;
+		pjob_store(ev, msg_ctx, sharename, jobid, pjob);
+	}
+err_out:
+	talloc_free(tmp_ctx);
+	return return_code;
+}
+
+/****************************************************************************
+ Get the queue status - do not update if db is out of date.
+****************************************************************************/
+
+static int get_queue_status(const char* sharename, print_status_struct *status)
+{
+	fstring keystr;
+	TDB_DATA data;
+	struct tdb_print_db *pdb = get_print_db_byname(sharename);
+	int len;
+
+	if (status) {
+		ZERO_STRUCTP(status);
+	}
+
+	if (!pdb)
+		return 0;
+
+	if (status) {
+		fstr_sprintf(keystr, "STATUS/%s", sharename);
+		data = tdb_fetch(pdb->tdb, string_tdb_data(keystr));
+		if (data.dptr) {
+			if (data.dsize == sizeof(print_status_struct))
+				/* this memcpy is ok since the status struct was
+				   not packed before storing it in the tdb */
+				memcpy(status, data.dptr, sizeof(print_status_struct));
+			SAFE_FREE(data.dptr);
+		}
+	}
+	len = tdb_fetch_int32(pdb->tdb, "INFO/total_jobs");
+	release_print_db(pdb);
+	return (len == -1 ? 0 : len);
+}
+
+/****************************************************************************
+ Determine the number of jobs in a queue.
+****************************************************************************/
+
+int print_queue_length(struct messaging_context *msg_ctx, int snum,
+		       print_status_struct *pstatus)
+{
+	const char* sharename = lp_const_servicename( snum );
+	print_status_struct status;
+	int len;
+
+	ZERO_STRUCT( status );
+
+	/* make sure the database is up to date */
+	if (print_cache_expired(lp_const_servicename(snum), True))
+		print_queue_update(msg_ctx, snum, False);
+
+	/* also fetch the queue status */
+	memset(&status, 0, sizeof(status));
+	len = get_queue_status(sharename, &status);
+
+	if (pstatus)
+		*pstatus = status;
+
+	return len;
+}
+
+/***************************************************************************
+ Allocate a jobid. Hold the lock for as short a time as possible.
+***************************************************************************/
+
+static WERROR allocate_print_jobid(struct tdb_print_db *pdb, int snum,
+				   const char *sharename, uint32_t *pjobid)
+{
+	int i;
+	uint32_t jobid;
+	enum TDB_ERROR terr;
+	int ret;
+
+	*pjobid = (uint32_t)-1;
+
+	for (i = 0; i < 3; i++) {
+		/* Lock the database - only wait 20 seconds. */
+		ret = tdb_lock_bystring_with_timeout(pdb->tdb,
+						     "INFO/nextjob", 20);
+		if (ret != 0) {
+			DEBUG(0, ("allocate_print_jobid: "
+				  "Failed to lock printing database %s\n",
+				  sharename));
+			terr = tdb_error(pdb->tdb);
+			return ntstatus_to_werror(map_nt_error_from_tdb(terr));
+		}
+
+		if (!tdb_fetch_uint32(pdb->tdb, "INFO/nextjob", &jobid)) {
+			terr = tdb_error(pdb->tdb);
+			if (terr != TDB_ERR_NOEXIST) {
+				DEBUG(0, ("allocate_print_jobid: "
+					  "Failed to fetch INFO/nextjob "
+					  "for print queue %s\n", sharename));
+				tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
+				return ntstatus_to_werror(map_nt_error_from_tdb(terr));
+			}
+			DEBUG(10, ("allocate_print_jobid: "
+				   "No existing jobid in %s\n", sharename));
+			jobid = 0;
+		}
+
+		DEBUG(10, ("allocate_print_jobid: "
+			   "Read jobid %u from %s\n", jobid, sharename));
+
+		jobid = NEXT_JOBID(jobid);
+
+		ret = tdb_store_int32(pdb->tdb, "INFO/nextjob", jobid);
+		if (ret != 0) {
+			terr = tdb_error(pdb->tdb);
+			DEBUG(3, ("allocate_print_jobid: "
+				  "Failed to store INFO/nextjob.\n"));
+			tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
+			return ntstatus_to_werror(map_nt_error_from_tdb(terr));
+		}
+
+		/* We've finished with the INFO/nextjob lock. */
+		tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
+
+		if (!print_job_exists(sharename, jobid)) {
+			break;
+		}
+		DEBUG(10, ("allocate_print_jobid: "
+			   "Found jobid %u in %s\n", jobid, sharename));
+	}
+
+	if (i > 2) {
+		DEBUG(0, ("allocate_print_jobid: "
+			  "Failed to allocate a print job for queue %s\n",
+			  sharename));
+		/* Probably full... */
+		return WERR_NO_SPOOL_SPACE;
+	}
+
+	/* Store a dummy placeholder. */
+	{
+		uint32_t tmp;
+		TDB_DATA dum;
+		dum.dptr = NULL;
+		dum.dsize = 0;
+		if (tdb_store(pdb->tdb, print_key(jobid, &tmp), dum,
+			      TDB_INSERT) != 0) {
+			DEBUG(3, ("allocate_print_jobid: "
+				  "jobid (%d) failed to store placeholder.\n",
+				  jobid ));
+			terr = tdb_error(pdb->tdb);
+			return ntstatus_to_werror(map_nt_error_from_tdb(terr));
+		}
+	}
+
+	*pjobid = jobid;
+	return WERR_OK;
+}
+
+/***************************************************************************
+ Do all checks needed to determine if we can start a job.
+***************************************************************************/
+
+static WERROR print_job_checks(const struct auth_session_info *server_info,
+			       struct messaging_context *msg_ctx,
+			       int snum, int *njobs)
+{
+	const char *sharename = lp_const_servicename(snum);
+	const struct loadparm_substitution *lp_sub =
+		loadparm_s3_global_substitution();
+	uint64_t dspace, dsize;
+	uint64_t minspace;
+	int ret;
+
+	if (!W_ERROR_IS_OK(print_access_check(server_info, msg_ctx, snum,
+					      PRINTER_ACCESS_USE))) {
+		DEBUG(3, ("print_job_checks: "
+			  "job start denied by security descriptor\n"));
+		return WERR_ACCESS_DENIED;
+	}
+
+	if (!print_time_access_check(server_info, msg_ctx, sharename)) {
+		DEBUG(3, ("print_job_checks: "
+			  "job start denied by time check\n"));
+		return WERR_ACCESS_DENIED;
+	}
+
+	/* see if we have sufficient disk space */
+	if (lp_min_print_space(snum)) {
+		minspace = lp_min_print_space(snum);
+		ret = sys_fsusage(lp_path(talloc_tos(), lp_sub, snum), &dspace, &dsize);
+		if (ret == 0 && dspace < 2*minspace) {
+			DEBUG(3, ("print_job_checks: "
+				  "disk space check failed.\n"));
+			return WERR_NO_SPOOL_SPACE;
+		}
+	}
+
+	/* for autoloaded printers, check that the printcap entry still exists */
+	if (lp_autoloaded(snum) &&
+	    !printer_list_printername_exists(sharename)) {
+		DEBUG(3, ("print_job_checks: printer name %s check failed.\n",
+			  sharename));
+		return WERR_ACCESS_DENIED;
+	}
+
+	/* Insure the maximum queue size is not violated */
+	*njobs = print_queue_length(msg_ctx, snum, NULL);
+	if (*njobs > lp_maxprintjobs(snum)) {
+		DEBUG(3, ("print_job_checks: Queue %s number of jobs (%d) "
+			  "larger than max printjobs per queue (%d).\n",
+			  sharename, *njobs, lp_maxprintjobs(snum)));
+		return WERR_NO_SPOOL_SPACE;
+	}
+
+	return WERR_OK;
+}
+
+/***************************************************************************
+ Create a job file.
+***************************************************************************/
+
+static WERROR print_job_spool_file(int snum, uint32_t jobid,
+				   const char *output_file,
+				   struct printjob *pjob)
+{
+	const struct loadparm_substitution *lp_sub =
+		loadparm_s3_global_substitution();
+	WERROR werr;
+	SMB_STRUCT_STAT st;
+	const char *path;
+	int len;
+	mode_t mask;
+
+	/* if this file is within the printer path, it means that smbd
+	 * is spooling it and will pass us control when it is finished.
+	 * Verify that the file name is ok, within path, and it is
+	 * already already there */
+	if (output_file) {
+		path = lp_path(talloc_tos(), lp_sub, snum);
+		len = strlen(path);
+		if (strncmp(output_file, path, len) == 0 &&
+		    (output_file[len - 1] == '/' || output_file[len] == '/')) {
+
+			/* verify path is not too long */
+			if (strlen(output_file) >= sizeof(pjob->filename)) {
+				return WERR_INVALID_NAME;
+			}
+
+			/* verify that the file exists */
+			if (sys_stat(output_file, &st, false) != 0) {
+				return WERR_INVALID_NAME;
+			}
+
+			fstrcpy(pjob->filename, output_file);
+
+			DEBUG(3, ("print_job_spool_file:"
+				  "External spooling activated\n"));
+
+			/* we do not open the file until spooling is done */
+			pjob->fd = -1;
+			pjob->status = PJOB_SMBD_SPOOLING;
+
+			return WERR_OK;
+		}
+	}
+
+	slprintf(pjob->filename, sizeof(pjob->filename)-1,
+		 "%s/%sXXXXXX", lp_path(talloc_tos(), lp_sub, snum),
+		 PRINT_SPOOL_PREFIX);
+	mask = umask(S_IRWXO | S_IRWXG);
+	pjob->fd = mkstemp(pjob->filename);
+	umask(mask);
+
+	if (pjob->fd == -1) {
+		werr = map_werror_from_unix(errno);
+		if (W_ERROR_EQUAL(werr, WERR_ACCESS_DENIED)) {
+			/* Common setup error, force a report. */
+			DEBUG(0, ("print_job_spool_file: "
+				  "insufficient permissions to open spool "
+				  "file %s.\n", pjob->filename));
+		} else {
+			/* Normal case, report at level 3 and above. */
+			DEBUG(3, ("print_job_spool_file: "
+				  "can't open spool file %s\n",
+				  pjob->filename));
+		}
+		return werr;
+	}
+
+	return WERR_OK;
+}
+
+/***************************************************************************
+ Start spooling a job - return the jobid.
+***************************************************************************/
+
+WERROR print_job_start(const struct auth_session_info *server_info,
+		       struct messaging_context *msg_ctx,
+		       const char *clientmachine,
+		       int snum, const char *docname, const char *filename,
+		       struct spoolss_DeviceMode *devmode, uint32_t *_jobid)
+{
+	uint32_t jobid;
+	char *path = NULL, *userstr = NULL;
+	struct printjob pjob;
+	const char *sharename = lp_const_servicename(snum);
+	struct tdb_print_db *pdb = get_print_db_byname(sharename);
+	const struct loadparm_substitution *lp_sub =
+		loadparm_s3_global_substitution();
+	int njobs;
+	WERROR werr;
+
+	if (!pdb) {
+		return WERR_INTERNAL_DB_CORRUPTION;
+	}
+
+	path = lp_path(talloc_tos(), lp_sub, snum);
+
+	werr = print_job_checks(server_info, msg_ctx, snum, &njobs);
+	if (!W_ERROR_IS_OK(werr)) {
+		release_print_db(pdb);
+		return werr;
+	}
+
+	DEBUG(10, ("print_job_start: "
+		   "Queue %s number of jobs (%d), max printjobs = %d\n",
+		   sharename, njobs, lp_maxprintjobs(snum)));
+
+	werr = allocate_print_jobid(pdb, snum, sharename, &jobid);
+	if (!W_ERROR_IS_OK(werr)) {
+		goto fail;
+	}
+
+	/* create the database entry */
+
+	ZERO_STRUCT(pjob);
+
+	pjob.pid = getpid();
+	pjob.jobid = jobid;
+	pjob.sysjob = -1;
+	pjob.fd = -1;
+	pjob.starttime = time(NULL);
+	pjob.status = LPQ_SPOOLING;
+	pjob.size = 0;
+	pjob.spooled = False;
+	pjob.smbjob = True;
+	pjob.devmode = devmode;
+
+	fstrcpy(pjob.jobname, docname);
+
+	fstrcpy(pjob.clientmachine, clientmachine);
+
+	userstr = talloc_sub_full(talloc_tos(),
+			      sharename,
+			      server_info->unix_info->sanitized_username,
+			      path, server_info->unix_token->gid,
+			      server_info->unix_info->sanitized_username,
+			      server_info->info->domain_name,
+			      lp_printjob_username(snum));
+	if (userstr == NULL) {
+		werr = WERR_NOT_ENOUGH_MEMORY;
+		goto fail;
+	}
+	strlcpy(pjob.user, userstr, sizeof(pjob.user));
+	TALLOC_FREE(userstr);
+
+	fstrcpy(pjob.queuename, lp_const_servicename(snum));
+
+	/* we have a job entry - now create the spool file */
+	werr = print_job_spool_file(snum, jobid, filename, &pjob);
+	if (!W_ERROR_IS_OK(werr)) {
+		goto fail;
+	}
+
+	pjob_store(global_event_context(), msg_ctx, sharename, jobid, &pjob);
+
+	/* Update the 'jobs added' entry used by print_queue_status. */
+	add_to_jobs_list(pdb, jobid, "INFO/jobs_added");
+
+	/* Ensure we keep a rough count of the number of total jobs... */
+	tdb_change_int32_atomic(pdb->tdb, "INFO/total_jobs", &njobs, 1);
+
+	release_print_db(pdb);
+
+	*_jobid = jobid;
+	return WERR_OK;
+
+fail:
+	if (jobid != -1) {
+		pjob_delete(global_event_context(), msg_ctx, sharename, jobid);
+	}
+
+	release_print_db(pdb);
+
+	DEBUG(3, ("print_job_start: returning fail. "
+		  "Error = %s\n", win_errstr(werr)));
+	return werr;
+}
+
+/****************************************************************************
+ Update the number of pages spooled to jobid
+****************************************************************************/
+
+void print_job_endpage(struct messaging_context *msg_ctx,
+		       int snum, uint32_t jobid)
+{
+	const char* sharename = lp_const_servicename(snum);
+	struct printjob *pjob;
+	TALLOC_CTX *tmp_ctx = talloc_new(msg_ctx);
+	if (tmp_ctx == NULL) {
+		return;
+	}
+
+	pjob = print_job_find(tmp_ctx, sharename, jobid);
+	if (!pjob) {
+		goto err_out;
+	}
+	/* don't allow another process to get this info - it is meaningless */
+	if (pjob->pid != getpid()) {
+		goto err_out;
+	}
+
+	pjob->page_count++;
+	pjob_store(global_event_context(), msg_ctx, sharename, jobid, pjob);
+err_out:
+	talloc_free(tmp_ctx);
+}
+
+/****************************************************************************
+ Print a file - called on closing the file. This spools the job.
+ If normal close is false then we're tearing down the jobs - treat as an
+ error.
+****************************************************************************/
+
+NTSTATUS print_job_end(struct messaging_context *msg_ctx, int snum,
+		       uint32_t jobid, enum file_close_type close_type)
+{
+	const char* sharename = lp_const_servicename(snum);
+	const struct loadparm_substitution *lp_sub =
+		loadparm_s3_global_substitution();
+	struct printjob *pjob;
+	int ret;
+	SMB_STRUCT_STAT sbuf;
+	struct printif *current_printif = get_printer_fns(snum);
+	NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
+	char *lpq_cmd;
+	TALLOC_CTX *tmp_ctx = talloc_new(msg_ctx);
+	if (tmp_ctx == NULL) {
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	pjob = print_job_find(tmp_ctx, sharename, jobid);
+	if (!pjob) {
+		status = NT_STATUS_PRINT_CANCELLED;
+		goto err_out;
+	}
+
+	if (pjob->spooled || pjob->pid != getpid()) {
+		status = NT_STATUS_ACCESS_DENIED;
+		goto err_out;
+	}
+
+	if (close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) {
+		if (pjob->status == PJOB_SMBD_SPOOLING) {
+			/* take over the file now, smbd is done */
+			if (sys_stat(pjob->filename, &sbuf, false) != 0) {
+				status = map_nt_error_from_unix(errno);
+				DEBUG(3, ("print_job_end: "
+					  "stat file failed for jobid %d\n",
+					  jobid));
+				goto fail;
+			}
+
+			pjob->status = LPQ_SPOOLING;
+
+		} else {
+
+			if ((sys_fstat(pjob->fd, &sbuf, false) != 0)) {
+				status = map_nt_error_from_unix(errno);
+				close(pjob->fd);
+				DEBUG(3, ("print_job_end: "
+					  "stat file failed for jobid %d\n",
+					  jobid));
+				goto fail;
+			}
+
+			close(pjob->fd);
+		}
+
+		pjob->size = sbuf.st_ex_size;
+	} else {
+
+		/*
+		 * Not a normal close, something has gone wrong. Cleanup.
+		 */
+		if (pjob->fd != -1) {
+			close(pjob->fd);
+		}
+		goto fail;
+	}
+
+	/* Technically, this is not quite right. If the printer has a separator
+	 * page turned on, the NT spooler prints the separator page even if the
+	 * print job is 0 bytes. 010215 JRR */
+	if (pjob->size == 0 || pjob->status == LPQ_DELETING) {
+		/* don't bother spooling empty files or something being deleted. */
+		DEBUG(5,("print_job_end: canceling spool of %s (%s)\n",
+			pjob->filename, pjob->size ? "deleted" : "zero length" ));
+		unlink(pjob->filename);
+		pjob_delete(global_event_context(), msg_ctx, sharename, jobid);
+		return NT_STATUS_OK;
+	}
+
+	/* don't strip out characters like '$' from the printername */
+	lpq_cmd = talloc_string_sub2(tmp_ctx,
+				     lp_lpq_command(snum),
+				     "%p",
+				     lp_printername(talloc_tos(), lp_sub, snum),
+				     false, false, false);
+	if (lpq_cmd == NULL) {
+		status = NT_STATUS_PRINT_CANCELLED;
+		goto fail;
+	}
+	lpq_cmd = talloc_sub_full(tmp_ctx,
+				      lp_servicename(talloc_tos(), lp_sub, snum),
+				      current_user_info.unix_name,
+				      "",
+				      get_current_gid(NULL),
+				      get_current_username(),
+				      current_user_info.domain,
+				      lpq_cmd);
+	if (lpq_cmd == NULL) {
+		status = NT_STATUS_PRINT_CANCELLED;
+		goto fail;
+	}
+
+	ret = (*(current_printif->job_submit))(snum, pjob,
+					       current_printif->type, lpq_cmd);
+	if (ret) {
+		status = NT_STATUS_PRINT_CANCELLED;
+		goto fail;
+	}
+
+	/* The print job has been successfully handed over to the back-end */
+
+	pjob->spooled = True;
+	pjob->status = LPQ_QUEUED;
+	pjob_store(global_event_context(), msg_ctx, sharename, jobid, pjob);
+
+	/* make sure the database is up to date */
+	if (print_cache_expired(lp_const_servicename(snum), True))
+		print_queue_update(msg_ctx, snum, False);
+
+	return NT_STATUS_OK;
+
+fail:
+
+	/* The print job was not successfully started. Cleanup */
+	/* Still need to add proper error return propagation! 010122:JRR */
+	pjob->fd = -1;
+	unlink(pjob->filename);
+	pjob_delete(global_event_context(), msg_ctx, sharename, jobid);
+err_out:
+	talloc_free(tmp_ctx);
+	return status;
+}
+
+/****************************************************************************
+ Get a snapshot of jobs in the system without traversing.
+****************************************************************************/
+
+static bool get_stored_queue_info(struct messaging_context *msg_ctx,
+				  struct tdb_print_db *pdb, int snum,
+				  int *pcount, print_queue_struct **ppqueue)
+{
+	const struct loadparm_substitution *lp_sub =
+		loadparm_s3_global_substitution();
+	TDB_DATA data, cgdata, jcdata;
+	print_queue_struct *queue = NULL;
+	uint32_t qcount = 0;
+	uint32_t extra_count = 0;
+	uint32_t changed_count = 0;
+	int total_count = 0;
+	size_t len = 0;
+	uint32_t i;
+	int max_reported_jobs = lp_max_reported_print_jobs(snum);
+	bool ret = false;
+	const char* sharename = lp_servicename(talloc_tos(), lp_sub, snum);
+	TALLOC_CTX *tmp_ctx = talloc_new(msg_ctx);
+	if (tmp_ctx == NULL) {
+		return false;
+	}
+
+	/* make sure the database is up to date */
+	if (print_cache_expired(lp_const_servicename(snum), True))
+		print_queue_update(msg_ctx, snum, False);
+
+	*pcount = 0;
+	*ppqueue = NULL;
+
+	ZERO_STRUCT(data);
+	ZERO_STRUCT(cgdata);
+
+	/* Get the stored queue data. */
+	data = tdb_fetch(pdb->tdb, string_tdb_data("INFO/linear_queue_array"));
+
+	if (data.dptr && data.dsize >= sizeof(qcount))
+		len += tdb_unpack(data.dptr + len, data.dsize - len, "d", &qcount);
+
+	/* Get the added jobs list. */
+	cgdata = tdb_fetch(pdb->tdb, string_tdb_data("INFO/jobs_added"));
+	if (cgdata.dptr != NULL && (cgdata.dsize % 4 == 0))
+		extra_count = cgdata.dsize/4;
+
+	/* Get the changed jobs list. */
+	jcdata = tdb_fetch(pdb->tdb, string_tdb_data("INFO/jobs_changed"));
+	if (jcdata.dptr != NULL && (jcdata.dsize % 4 == 0))
+		changed_count = jcdata.dsize / 4;
+
+	DEBUG(5,("get_stored_queue_info: qcount = %u, extra_count = %u\n", (unsigned int)qcount, (unsigned int)extra_count));
+
+	/* Allocate the queue size. */
+	if (qcount == 0 && extra_count == 0)
+		goto out;
+
+	if ((queue = SMB_MALLOC_ARRAY(print_queue_struct, qcount + extra_count)) == NULL)
+		goto out;
+
+	/* Retrieve the linearised queue data. */
+
+	for(i = 0; i < qcount; i++) {
+		uint32_t qjob, qsize, qpage_count, qstatus, qpriority, qtime;
+		len += tdb_unpack(data.dptr + len, data.dsize - len, "ddddddff",
+				&qjob,
+				&qsize,
+				&qpage_count,
+				&qstatus,
+				&qpriority,
+				&qtime,
+				queue[i].fs_user,
+				queue[i].fs_file);
+		queue[i].sysjob = qjob;
+		queue[i].size = qsize;
+		queue[i].page_count = qpage_count;
+		queue[i].status = qstatus;
+		queue[i].priority = qpriority;
+		queue[i].time = qtime;
+	}
+
+	total_count = qcount;
+
+	/* Add new jobids to the queue. */
+	for (i = 0; i < extra_count; i++) {
+		uint32_t jobid;
+		struct printjob *pjob;
+
+		jobid = IVAL(cgdata.dptr, i*4);
+		DEBUG(5,("get_stored_queue_info: added job = %u\n", (unsigned int)jobid));
+		pjob = print_job_find(tmp_ctx, lp_const_servicename(snum), jobid);
+		if (!pjob) {
+			DEBUG(5,("get_stored_queue_info: failed to find added job = %u\n", (unsigned int)jobid));
+			remove_from_jobs_added(sharename, jobid);
+			continue;
+		}
+
+		queue[total_count].sysjob = pjob->sysjob;
+		queue[total_count].size = pjob->size;
+		queue[total_count].page_count = pjob->page_count;
+		queue[total_count].status = pjob->status;
+		queue[total_count].priority = 1;
+		queue[total_count].time = pjob->starttime;
+		fstrcpy(queue[total_count].fs_user, pjob->user);
+		fstrcpy(queue[total_count].fs_file, pjob->jobname);
+		total_count++;
+		talloc_free(pjob);
+	}
+
+	/* Update the changed jobids. */
+	for (i = 0; i < changed_count; i++) {
+		uint32_t jobid = IVAL(jcdata.dptr, i * 4);
+		struct printjob *pjob;
+		uint32_t j;
+		bool found = false;
+
+		pjob = print_job_find(tmp_ctx, sharename, jobid);
+		if (pjob == NULL) {
+			DEBUG(5,("get_stored_queue_info: failed to find "
+				 "changed job = %u\n",
+				 (unsigned int)jobid));
+			remove_from_jobs_changed(sharename, jobid);
+			continue;
+		}
+
+		for (j = 0; j < total_count; j++) {
+			if (queue[j].sysjob == pjob->sysjob) {
+				found = true;
+				break;
+			}
+		}
+
+		if (found) {
+			DEBUG(5,("get_stored_queue_info: changed job: %u\n",
+				 (unsigned int)jobid));
+
+			queue[j].sysjob = pjob->sysjob;
+			queue[j].size = pjob->size;
+			queue[j].page_count = pjob->page_count;
+			queue[j].status = pjob->status;
+			queue[j].priority = 1;
+			queue[j].time = pjob->starttime;
+			fstrcpy(queue[j].fs_user, pjob->user);
+			fstrcpy(queue[j].fs_file, pjob->jobname);
+			talloc_free(pjob);
+
+			DEBUG(5,("updated queue[%u], jobid: %u, sysjob: %u, "
+				 "jobname: %s\n",
+				 (unsigned int)j, (unsigned int)jobid,
+				 (unsigned int)queue[j].sysjob, pjob->jobname));
+		}
+
+		remove_from_jobs_changed(sharename, jobid);
+	}
+
+	/* Sort the queue by submission time otherwise they are displayed
+	   in hash order. */
+
+	TYPESAFE_QSORT(queue, total_count, printjob_comp);
+
+	DEBUG(5,("get_stored_queue_info: total_count = %u\n", (unsigned int)total_count));
+
+	if (max_reported_jobs && total_count > max_reported_jobs)
+		total_count = max_reported_jobs;
+
+	*ppqueue = queue;
+	*pcount = total_count;
+
+	ret = true;
+
+  out:
+
+	SAFE_FREE(data.dptr);
+	SAFE_FREE(cgdata.dptr);
+	talloc_free(tmp_ctx);
+	return ret;
+}
+
+/****************************************************************************
+ Get a printer queue listing.
+ set queue = NULL and status = NULL if you just want to update the cache
+****************************************************************************/
+
+int print_queue_status(struct messaging_context *msg_ctx, int snum,
+		       print_queue_struct **ppqueue,
+		       print_status_struct *status)
+{
+	fstring keystr;
+	TDB_DATA data, key;
+	const char *sharename;
+	struct tdb_print_db *pdb;
+	int count = 0;
+
+	/* make sure the database is up to date */
+
+	if (print_cache_expired(lp_const_servicename(snum), True))
+		print_queue_update(msg_ctx, snum, False);
+
+	/* return if we are done */
+	if ( !ppqueue || !status )
+		return 0;
+
+	*ppqueue = NULL;
+	sharename = lp_const_servicename(snum);
+	pdb = get_print_db_byname(sharename);
+
+	if (!pdb)
+		return 0;
+
+	/*
+	 * Fetch the queue status.  We must do this first, as there may
+	 * be no jobs in the queue.
+	 */
+
+	ZERO_STRUCTP(status);
+	slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", sharename);
+	key = string_tdb_data(keystr);
+
+	data = tdb_fetch(pdb->tdb, key);
+	if (data.dptr) {
+		if (data.dsize == sizeof(*status)) {
+			/* this memcpy is ok since the status struct was
+			   not packed before storing it in the tdb */
+			memcpy(status, data.dptr, sizeof(*status));
+		}
+		SAFE_FREE(data.dptr);
+	}
+
+	/*
+	 * Now, fetch the print queue information.  We first count the number
+	 * of entries, and then only retrieve the queue if necessary.
+	 */
+
+	if (!get_stored_queue_info(msg_ctx, pdb, snum, &count, ppqueue)) {
+		release_print_db(pdb);
+		return 0;
+	}
+
+	release_print_db(pdb);
+	return count;
+}
+
+/****************************************************************************
+ Pause a queue.
+****************************************************************************/
+
+WERROR print_queue_pause(const struct auth_session_info *server_info,
+			 struct messaging_context *msg_ctx, int snum)
+{
+	int ret;
+	struct printif *current_printif = get_printer_fns( snum );
+
+	if (!W_ERROR_IS_OK(print_access_check(server_info, msg_ctx, snum,
+					      PRINTER_ACCESS_ADMINISTER))) {
+		return WERR_ACCESS_DENIED;
+	}
+
+
+	become_root();
+
+	ret = (*(current_printif->queue_pause))(snum);
+
+	unbecome_root();
+
+	if (ret != 0) {
+		return WERR_INVALID_PARAMETER;
+	}
+
+	/* force update the database */
+	print_cache_flush(lp_const_servicename(snum));
+
+	/* Send a printer notify message */
+
+	notify_printer_status(global_event_context(), msg_ctx, snum,
+			      PRINTER_STATUS_PAUSED);
+
+	return WERR_OK;
+}
+
+/****************************************************************************
+ Resume a queue.
+****************************************************************************/
+
+WERROR print_queue_resume(const struct auth_session_info *server_info,
+			  struct messaging_context *msg_ctx, int snum)
+{
+	int ret;
+	struct printif *current_printif = get_printer_fns( snum );
+
+	if (!W_ERROR_IS_OK(print_access_check(server_info, msg_ctx, snum,
+					      PRINTER_ACCESS_ADMINISTER))) {
+		return WERR_ACCESS_DENIED;
+	}
+
+	become_root();
+
+	ret = (*(current_printif->queue_resume))(snum);
+
+	unbecome_root();
+
+	if (ret != 0) {
+		return WERR_INVALID_PARAMETER;
+	}
+
+	/* make sure the database is up to date */
+	if (print_cache_expired(lp_const_servicename(snum), True))
+		print_queue_update(msg_ctx, snum, True);
+
+	/* Send a printer notify message */
+
+	notify_printer_status(global_event_context(), msg_ctx, snum,
+			      PRINTER_STATUS_OK);
+
+	return WERR_OK;
+}
+
+/****************************************************************************
+ Purge a queue - implemented by deleting all jobs that we can delete.
+****************************************************************************/
+
+WERROR print_queue_purge(const struct auth_session_info *server_info,
+			 struct messaging_context *msg_ctx, int snum)
+{
+	print_queue_struct *queue;
+	print_status_struct status;
+	int njobs, i;
+	bool can_job_admin;
+
+	/* Force and update so the count is accurate (i.e. not a cached count) */
+	print_queue_update(msg_ctx, snum, True);
+
+	can_job_admin = W_ERROR_IS_OK(print_access_check(server_info,
+							 msg_ctx,
+							 snum,
+							JOB_ACCESS_ADMINISTER));
+	njobs = print_queue_status(msg_ctx, snum, &queue, &status);
+
+	if ( can_job_admin )
+		become_root();
+
+	for (i = 0; i < njobs; i++) {
+		struct tdb_print_db *pdb;
+		int jobid;
+		bool owner;
+		pdb = get_print_db_byname(lp_const_servicename(snum));
+		if (pdb == NULL) {
+			DEBUG(1, ("failed to find printdb for %s\n",
+				  lp_const_servicename(snum)));
+			continue;
+		}
+		jobid = sysjob_to_jobid_pdb(pdb, queue[i].sysjob);
+		if (jobid == (uint32_t)-1) {
+			DEBUG(2, ("jobid for system job %d not found\n",
+				  queue[i].sysjob));
+			continue;	/* unix job */
+		}
+		owner = is_owner(server_info, lp_const_servicename(snum),
+				 jobid);
+
+		if (owner || can_job_admin) {
+			print_job_delete1(global_event_context(), msg_ctx,
+					  snum, jobid);
+		}
+	}
+
+	if ( can_job_admin )
+		unbecome_root();
+
+	/* update the cache */
+	print_queue_update(msg_ctx, snum, True);
+
+	SAFE_FREE(queue);
+
+	return WERR_OK;
+}