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 2 of the License, or
+ 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,
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, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
extern SIG_ATOMIC_T got_sig_term;
extern SIG_ATOMIC_T reload_after_sighup;
+extern struct current_user current_user;
+extern userdom_struct current_user_info;
/* Current printer interface */
-static BOOL remove_from_jobs_changed(const char* sharename, uint32 jobid);
+static bool remove_from_jobs_changed(const char* sharename, uint32 jobid);
/*
the printing backend revolves around a tdb database that stores the
ZERO_STRUCT( jinfo );
fstrcpy( jinfo.sharename, sharename );
jinfo.jobid = jobid;
- key.dptr = (char*)&jinfo;
+ key.dptr = (uint8 *)&jinfo;
key.dsize = sizeof(jinfo);
data = tdb_fetch(rap_tdb, key);
if (rap_jobid == 0)
rap_jobid = ++next_rap_jobid;
SSVAL(buf,0,rap_jobid);
- data.dptr = (char*)buf;
+ data.dptr = buf;
data.dsize = sizeof(rap_jobid);
tdb_store(rap_tdb, key, data, TDB_REPLACE);
tdb_store(rap_tdb, data, key, TDB_REPLACE);
return rap_jobid;
}
-BOOL rap_to_pjobid(uint16 rap_jobid, fstring sharename, uint32 *pjobid)
+bool rap_to_pjobid(uint16 rap_jobid, fstring sharename, uint32 *pjobid)
{
TDB_DATA data, key;
uint8 buf[2];
return False;
SSVAL(buf,0,rap_jobid);
- key.dptr = (char*)buf;
+ key.dptr = buf;
key.dsize = sizeof(rap_jobid);
data = tdb_fetch(rap_tdb, key);
if ( data.dptr && data.dsize == sizeof(struct rap_jobid_key) )
ZERO_STRUCT( jinfo );
fstrcpy( jinfo.sharename, sharename );
jinfo.jobid = jobid;
- key.dptr = (char*)&jinfo;
+ key.dptr = (uint8 *)&jinfo;
key.dsize = sizeof(jinfo);
data = tdb_fetch(rap_tdb, key);
rap_jobid = SVAL(data.dptr, 0);
SAFE_FREE(data.dptr);
SSVAL(buf,0,rap_jobid);
- data.dptr = (char*)buf;
+ data.dptr = buf;
data.dsize = sizeof(rap_jobid);
tdb_delete(rap_tdb, key);
tdb_delete(rap_tdb, data);
Initialise the printing backend. Called once at startup before the fork().
****************************************************************************/
-BOOL print_backend_init(void)
+bool print_backend_init(struct messaging_context *msg_ctx)
{
const char *sversion = "INFO/version";
pstring printing_path;
close_all_print_db(); /* Don't leave any open. */
/* do NT print initialization... */
- return nt_printing_init();
+ return nt_printing_init(msg_ctx);
}
/****************************************************************************
TDB_DATA ret;
SIVAL(&j, 0, jobid);
- ret.dptr = (void *)&j;
+ ret.dptr = (uint8 *)&j;
ret.dsize = sizeof(j);
return ret;
}
unpack a pjob from a tdb buffer
***********************************************************************/
-int unpack_pjob( char* buf, int buflen, struct printjob *pjob )
+int unpack_pjob( uint8 *buf, int buflen, struct printjob *pjob )
{
int len = 0;
int used;
static void pjob_store_notify(const char* sharename, uint32 jobid, struct printjob *old_data,
struct printjob *new_data)
{
- BOOL new_job = False;
+ bool new_job = False;
if (!old_data)
new_job = True;
Store a job structure back to the database.
****************************************************************************/
-static BOOL pjob_store(const char* sharename, uint32 jobid, struct printjob *pjob)
+static bool pjob_store(const char* sharename, uint32 jobid, struct printjob *pjob)
{
TDB_DATA old_data, new_data;
- BOOL ret = False;
+ bool ret = False;
struct tdb_print_db *pdb = get_print_db_byname(sharename);
- char *buf = NULL;
+ uint8 *buf = NULL;
int len, newlen, buflen;
len += pack_devicemode(pjob->nt_devmode, buf+len, buflen-len);
if (buflen != len) {
- buf = (char *)SMB_REALLOC(buf, len);
+ buf = (uint8 *)SMB_REALLOC(buf, len);
if (!buf) {
DEBUG(0,("pjob_store: failed to enlarge buffer!\n"));
goto done;
if (!pdb)
return (pid_t)-1;
slprintf(keystr, sizeof(keystr)-1, "UPDATING/%s", sharename);
- key.dptr = keystr;
- key.dsize = strlen(keystr);
+ key = string_tdb_data(keystr);
data = tdb_fetch(pdb->tdb, key);
release_print_db(pdb);
in the tdb.
****************************************************************************/
-static void set_updating_pid(const fstring sharename, BOOL updating)
+static void set_updating_pid(const fstring sharename, bool updating)
{
fstring keystr;
TDB_DATA key;
return;
slprintf(keystr, sizeof(keystr)-1, "UPDATING/%s", sharename);
- key.dptr = keystr;
- key.dsize = strlen(keystr);
+ key = string_tdb_data(keystr);
DEBUG(5, ("set_updating_pid: %s updating lpq cache for print share %s\n",
updating ? "" : "not ",
}
SIVAL( buffer, 0, updating_pid);
- data.dptr = (void *)buffer;
+ data.dptr = buffer;
data.dsize = 4; /* we always assume this is a 4 byte value */
tdb_store(pdb->tdb, key, data, TDB_REPLACE);
print_queue_struct *queue = pts->queue;
size_t len;
size_t i;
- uint qcount;
+ unsigned int qcount;
if (max_reported_jobs && (max_reported_jobs < pts->qcount))
pts->qcount = max_reported_jobs;
queue[i].fs_file);
}
- if ((data.dptr = SMB_MALLOC(data.dsize)) == NULL)
+ if ((data.dptr = (uint8 *)SMB_MALLOC(data.dsize)) == NULL)
return;
len = 0;
Check if the print queue has been updated recently enough.
****************************************************************************/
-static BOOL print_cache_expired(const char *sharename, BOOL check_pending)
+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;
+ bool result = False;
if (!pdb)
return False;
/* store the new queue status structure */
slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", sharename);
- key.dptr = keystr;
- key.dsize = strlen(keystr);
+ key = string_tdb_data(keystr);
status.qcount = qcount;
- data.dptr = (void *)&status;
+ data.dptr = (uint8 *)&status;
data.dsize = sizeof(status);
tdb_store(pdb->tdb, key, data, TDB_REPLACE);
/****************************************************************************
this is the receive function of the background lpq updater
****************************************************************************/
-static void print_queue_receive(int msg_type, struct process_id src,
- void *buf, size_t msglen)
+static 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;
pstring lpqcommand, lprmcommand;
int printing_type;
size_t len;
- len = tdb_unpack( buf, msglen, "fdPP",
+ len = tdb_unpack( (uint8 *)data->data, data->length, "fdPP",
sharename,
&printing_type,
lpqcommand,
/* Child. */
DEBUG(5,("start_background_queue: background LPQ thread started\n"));
- claim_connection( NULL, "smbd lpq backend", 0, False,
+ claim_connection( NULL, "smbd lpq backend",
FLAG_MSG_GENERAL|FLAG_MSG_SMBD|FLAG_MSG_PRINT_GENERAL);
if (!locking_init(0)) {
exit(1);
}
- message_register(MSG_PRINTER_UPDATE, print_queue_receive);
+ messaging_register(smbd_messaging_context(), NULL,
+ MSG_PRINTER_UPDATE, print_queue_receive);
DEBUG(5,("start_background_queue: background LPQ thread waiting for messages\n"));
while (1) {
/* now check for messages */
DEBUG(10,("start_background_queue: background LPQ thread got a message\n"));
- message_dispatch();
+ message_dispatch(smbd_messaging_context());
/* process any pending print change notify messages */
- print_notify_send_messages(0);
+ print_notify_send_messages(smbd_messaging_context(),
+ 0);
}
}
}
update the internal database from the system print queue for a queue
****************************************************************************/
-static void print_queue_update(int snum, BOOL force)
+static void print_queue_update(int snum, bool force)
{
- extern struct current_user current_user;
- extern userdom_struct current_user_info;
fstring key;
fstring sharename;
pstring lpqcommand, lprmcommand;
- char *buffer = NULL;
+ uint8 *buffer = NULL;
size_t len = 0;
size_t newlen;
struct tdb_print_db *pdb;
lpqcommand,
lprmcommand );
- buffer = SMB_XMALLOC_ARRAY( char, len );
+ buffer = SMB_XMALLOC_ARRAY( uint8, len );
/* now pack the buffer */
newlen = tdb_pack( buffer, len, "fdPP",
/* finally send the message */
- become_root();
- message_send_pid(pid_to_procid(background_lpq_updater_pid),
- MSG_PRINTER_UPDATE, buffer, len, False);
- unbecome_root();
+ messaging_send_buf(smbd_messaging_context(),
+ pid_to_procid(background_lpq_updater_pid),
+ MSG_PRINTER_UPDATE, (uint8 *)buffer, len);
SAFE_FREE( buffer );
updates only to interested smbd's.
****************************************************************************/
-BOOL print_notify_register_pid(int snum)
+bool print_notify_register_pid(int snum)
{
TDB_DATA data;
struct tdb_print_db *pdb = NULL;
TDB_CONTEXT *tdb = NULL;
const char *printername;
uint32 mypid = (uint32)sys_getpid();
- BOOL ret = False;
+ bool ret = False;
size_t i;
/* if (snum == -1), then the change notify request was
if (i == data.dsize) {
/* We weren't in the list. Realloc. */
- data.dptr = SMB_REALLOC(data.dptr, data.dsize + 8);
+ data.dptr = (uint8 *)SMB_REALLOC(data.dptr, data.dsize + 8);
if (!data.dptr) {
DEBUG(0,("print_notify_register_pid: Relloc fail for printer %s\n",
printername));
updates only to interested smbd's.
****************************************************************************/
-BOOL print_notify_deregister_pid(int snum)
+bool print_notify_deregister_pid(int snum)
{
TDB_DATA data;
struct tdb_print_db *pdb = NULL;
const char *printername;
uint32 mypid = (uint32)sys_getpid();
size_t i;
- BOOL ret = False;
+ bool ret = False;
/* if ( snum == -1 ), we are deregister a print server handle
which means to deregister on all print queues */
Check if a jobid is valid. It is valid if it exists in the database.
****************************************************************************/
-BOOL print_job_exists(const char* sharename, uint32 jobid)
+bool print_job_exists(const char* sharename, uint32 jobid)
{
struct tdb_print_db *pdb = get_print_db_byname(sharename);
- BOOL ret;
+ bool ret;
if (!pdb)
return False;
Set the place in the queue for a job.
****************************************************************************/
-BOOL print_job_set_place(const char *sharename, uint32 jobid, int place)
+bool print_job_set_place(const char *sharename, uint32 jobid, int place)
{
DEBUG(2,("print_job_set_place not implemented yet\n"));
return False;
Set the name of a job. Only possible for owner.
****************************************************************************/
-BOOL print_job_set_name(const char *sharename, uint32 jobid, char *name)
+bool print_job_set_name(const char *sharename, uint32 jobid, char *name)
{
struct printjob *pjob;
Remove a jobid from the 'jobs changed' list.
***************************************************************************/
-static BOOL remove_from_jobs_changed(const char* sharename, uint32 jobid)
+static bool remove_from_jobs_changed(const char* sharename, uint32 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;
+ bool ret = False;
+ bool gotlock = False;
if (!pdb) {
return False;
Delete a print job - don't update queue.
****************************************************************************/
-static BOOL print_job_delete1(int snum, uint32 jobid)
+static bool print_job_delete1(int snum, uint32 jobid)
{
const char* sharename = lp_const_servicename(snum);
struct printjob *pjob = print_job_find(sharename, jobid);
Return true if the current user owns the print job.
****************************************************************************/
-static BOOL is_owner(struct current_user *user, const char *servicename,
+static bool is_owner(struct current_user *user, const char *servicename,
uint32 jobid)
{
struct printjob *pjob = print_job_find(servicename, jobid);
Delete a print job.
****************************************************************************/
-BOOL print_job_delete(struct current_user *user, int snum, uint32 jobid, WERROR *errcode)
+bool print_job_delete(struct current_user *user, int snum, uint32 jobid, WERROR *errcode)
{
const char* sharename = lp_const_servicename( snum );
struct printjob *pjob;
- BOOL owner;
+ bool owner;
char *fname;
*errcode = WERR_OK;
Pause a job.
****************************************************************************/
-BOOL print_job_pause(struct current_user *user, int snum, uint32 jobid, WERROR *errcode)
+bool print_job_pause(struct current_user *user, int snum, uint32 jobid, WERROR *errcode)
{
const char* sharename = lp_const_servicename(snum);
struct printjob *pjob;
Resume a job.
****************************************************************************/
-BOOL print_job_resume(struct current_user *user, int snum, uint32 jobid, WERROR *errcode)
+bool print_job_resume(struct current_user *user, int snum, uint32 jobid, WERROR *errcode)
{
const char *sharename = lp_const_servicename(snum);
struct printjob *pjob;
Allocate a jobid. Hold the lock for as short a time as possible.
***************************************************************************/
-static BOOL allocate_print_jobid(struct tdb_print_db *pdb, int snum, const char *sharename, uint32 *pjobid)
+static bool allocate_print_jobid(struct tdb_print_db *pdb, int snum, const char *sharename, uint32 *pjobid)
{
int i;
uint32 jobid;
Append a jobid to the 'jobs changed' list.
***************************************************************************/
-static BOOL add_to_jobs_changed(struct tdb_print_db *pdb, uint32 jobid)
+static bool add_to_jobs_changed(struct tdb_print_db *pdb, uint32 jobid)
{
TDB_DATA data;
uint32 store_jobid;
SIVAL(&store_jobid, 0, jobid);
- data.dptr = (char *)&store_jobid;
+ data.dptr = (uint8 *)&store_jobid;
data.dsize = 4;
DEBUG(10,("add_to_jobs_changed: Added jobid %u\n", (unsigned int)jobid ));
fstrcpy(pjob.jobname, jobname);
if ((vuser = get_valid_user_struct(user->vuid)) != NULL) {
- fstrcpy(pjob.user, vuser->user.smb_name);
+ fstrcpy(pjob.user, lp_printjob_username(snum));
+ standard_sub_basic(vuser->user.smb_name, vuser->user.domain,
+ pjob.user, sizeof(pjob.user)-1);
+ /* ensure NULL termination */
+ pjob.user[sizeof(pjob.user)-1] = '\0';
} else {
fstrcpy(pjob.user, uidtoname(user->ut.uid));
}
error.
****************************************************************************/
-BOOL print_job_end(int snum, uint32 jobid, enum file_close_type close_type)
+bool print_job_end(int snum, uint32 jobid, enum file_close_type close_type)
{
const char* sharename = lp_const_servicename(snum);
struct printjob *pjob;
Get a snapshot of jobs in the system without traversing.
****************************************************************************/
-static BOOL get_stored_queue_info(struct tdb_print_db *pdb, int snum, int *pcount, print_queue_struct **ppqueue)
+static bool get_stored_queue_info(struct tdb_print_db *pdb, int snum, int *pcount, print_queue_struct **ppqueue)
{
TDB_DATA data, cgdata;
print_queue_struct *queue = NULL;
size_t len = 0;
uint32 i;
int max_reported_jobs = lp_max_reported_jobs(snum);
- BOOL ret = False;
+ bool ret = False;
const char* sharename = lp_servicename(snum);
/* make sure the database is up to date */
ZERO_STRUCTP(status);
slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", sharename);
- key.dptr = keystr;
- key.dsize = strlen(keystr);
+ key = string_tdb_data(keystr);
+
data = tdb_fetch(pdb->tdb, key);
if (data.dptr) {
if (data.dsize == sizeof(*status)) {
Pause a queue.
****************************************************************************/
-BOOL print_queue_pause(struct current_user *user, int snum, WERROR *errcode)
+bool print_queue_pause(struct current_user *user, int snum, WERROR *errcode)
{
int ret;
struct printif *current_printif = get_printer_fns( snum );
Resume a queue.
****************************************************************************/
-BOOL print_queue_resume(struct current_user *user, int snum, WERROR *errcode)
+bool print_queue_resume(struct current_user *user, int snum, WERROR *errcode)
{
int ret;
struct printif *current_printif = get_printer_fns( snum );
Purge a queue - implemented by deleting all jobs that we can delete.
****************************************************************************/
-BOOL print_queue_purge(struct current_user *user, int snum, WERROR *errcode)
+bool print_queue_purge(struct current_user *user, int snum, WERROR *errcode)
{
print_queue_struct *queue;
print_status_struct status;
int njobs, i;
- BOOL can_job_admin;
+ bool can_job_admin;
/* Force and update so the count is accurate (i.e. not a cached count) */
print_queue_update(snum, True);
become_root();
for (i=0;i<njobs;i++) {
- BOOL owner = is_owner(user, lp_const_servicename(snum), queue[i].job);
+ bool owner = is_owner(user, lp_const_servicename(snum), queue[i].job);
if (owner || can_job_admin) {
print_job_delete1(snum, queue[i].job);