/* 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 2 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "printing.h" /* Current printer interface */ static struct printif *current_printif = &generic_printif; /* the printing backend revolves around a tdb database that stores the SMB view of the print queue The key for this database is a jobid - a internally generated number that uniquely identifies a print job reading the print queue involves two steps: - possibly running lpq and updating the internal database from that - reading entries from the database jobids are assigned when a job starts spooling. */ /*************************************************************************** Nightmare. LANMAN jobid's are 16 bit numbers..... We must map them to 32 bit RPC jobids.... JRA. ***************************************************************************/ static TDB_CONTEXT *rap_tdb; static uint16 next_rap_jobid; uint16 pjobid_to_rap(uint32 jobid) { uint16 rap_jobid; TDB_DATA data, key; if (!rap_tdb) { /* Create the in-memory tdb. */ rap_tdb = tdb_open_log(NULL, 0, TDB_INTERNAL, (O_RDWR|O_CREAT), 0644); if (!rap_tdb) return 0; } key.dptr = (char *)&jobid; key.dsize = sizeof(jobid); data = tdb_fetch(rap_tdb, key); if (data.dptr && data.dsize == sizeof(uint16)) { memcpy(&rap_jobid, data.dptr, sizeof(uint16)); SAFE_FREE(data.dptr); return rap_jobid; } /* Not found - create and store mapping. */ rap_jobid = ++next_rap_jobid; if (rap_jobid == 0) rap_jobid = ++next_rap_jobid; data.dptr = (char *)&rap_jobid; data.dsize = sizeof(rap_jobid); tdb_store(rap_tdb, key, data, TDB_REPLACE); tdb_store(rap_tdb, data, key, TDB_REPLACE); return rap_jobid; } uint32 rap_to_pjobid(uint16 rap_jobid) { TDB_DATA data, key; uint32 jobid = 0; if (!rap_tdb) return 0; key.dptr = (char *)&rap_jobid; key.dsize = sizeof(rap_jobid); data = tdb_fetch(rap_tdb, key); if (data.dptr && data.dsize == sizeof(uint32)) { memcpy(&jobid, data.dptr, sizeof(uint32)); SAFE_FREE(data.dptr); } return jobid; } static void rap_jobid_delete(uint32 jobid) { TDB_DATA key, data; uint16 rap_jobid; if (!rap_tdb) return; key.dptr = (char *)&jobid; key.dsize = sizeof(jobid); data = tdb_fetch(rap_tdb, key); if (!data.dptr || (data.dsize != sizeof(uint16))) return; memcpy(&rap_jobid, data.dptr, sizeof(uint16)); SAFE_FREE(data.dptr); data.dptr = (char *)&rap_jobid; data.dsize = sizeof(rap_jobid); tdb_delete(rap_tdb, key); tdb_delete(rap_tdb, data); } static pid_t local_pid; /* Mapping between printer names and queue id's in job id's. */ struct printer_queueid_map { struct printer_queueid_map *next, *prev; char *printername; uint32 queueid; }; static struct printer_queueid_map *printer_queueid_map_head; static uint32 last_queueid; #define QUEUEID_BITS 12 #define QUEUEID_MASK ((1<<(QUEUEID_BITS))-1) #define QUEUEID_TO_JOBID(queueid) (((queueid) & QUEUEID_MASK) << 20 ) /**************************************************************************** Create an association between a printer name and a queueid. Used to encode the printer queueid in jobid's. This could be converted to use an internal tdb if searching the list is too slow. JRA. ****************************************************************************/ BOOL create_printer_queueid(const char *printername) { struct printer_queueid_map *p; for (p = printer_queueid_map_head; p; p = p->next) { if (strequal(p->printername, printername)) return True; } p = (struct printer_queueid_map *)malloc(sizeof(*p)); if (!p) { DEBUG(0,("create_printer_queueid: malloc fail !\n")); return False; } ZERO_STRUCTP(p); p->printername = strdup(printername); if (!p->printername) { DEBUG(0,("create_printer_queueid: malloc fail !\n")); SAFE_FREE(p); return False; } p->queueid = (++last_queueid); if (p->queueid > QUEUEID_MASK) { DEBUG(0,("create_printer_queueid: malloc fail !\n")); SAFE_FREE(p->printername); SAFE_FREE(p); return False; } DLIST_ADD(printer_queueid_map_head, p); return True; } void set_register_printer_fn(void) { extern BOOL (*register_printer_fn)(const char *); register_printer_fn = create_printer_queueid; } /**************************************************************************** Lookups. ****************************************************************************/ static uint32 get_printer_queueid_byname(const char *printername) { struct printer_queueid_map *p; for (p = printer_queueid_map_head; p; p = p->next) { if (strequal(p->printername, printername)) return p->queueid; } return 0; } /**************************************************************************** Lookups. ****************************************************************************/ static const char *get_printer_name_byjobid(uint32 jobid) { struct printer_queueid_map *p; uint32 queueid = (((jobid)>>20) & QUEUEID_MASK); for (p = printer_queueid_map_head; p; p = p->next) { if (p->queueid == queueid) return p->printername; } return NULL; } static int get_queue_status(int, print_status_struct *); #define MAX_PRINT_DBS_OPEN 1 struct tdb_print_db { struct tdb_print_db *next, *prev; TDB_CONTEXT *tdb; fstring printer_name; }; static struct tdb_print_db *print_db_head; /**************************************************************************** Function to find or create the printer specific job tdb given a printername. Limits the number of tdb's open to MAX_PRINT_DBS_OPEN. ****************************************************************************/ static struct tdb_print_db *get_print_db_byname(const char *printername) { struct tdb_print_db *p, *last_entry; int num_open = 0; pstring printdb_path; for (p = print_db_head, last_entry = print_db_head; p; p = p->next) { if (p->tdb && strequal(p->printer_name, printername)) { DLIST_PROMOTE(print_db_head, p); return p; } num_open++; last_entry = p; } /* Not found. */ if (num_open >= MAX_PRINT_DBS_OPEN) { /* Recycle the last entry. */ DLIST_PROMOTE(print_db_head, last_entry); if (print_db_head->tdb) { if (tdb_close(print_db_head->tdb)) { DEBUG(0,("get_print_db: Failed to close tdb for printer %s\n", print_db_head->printer_name )); return NULL; } } p = print_db_head; ZERO_STRUCTP(p); } else { /* Create one. */ p = (struct tdb_print_db *)malloc(sizeof(struct tdb_print_db)); if (!p) { DEBUG(0,("get_print_db: malloc fail !\n")); return NULL; } ZERO_STRUCTP(p); DLIST_ADD(print_db_head, p); } pstrcpy(printdb_path, lock_path("printing/")); pstrcat(printdb_path, printername); pstrcat(printdb_path, ".tdb"); p->tdb = tdb_open_log(printdb_path, 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0600); if (!p->tdb) { DEBUG(0,("get_print_db: Failed to open printer backend database %s.\n", printdb_path )); DLIST_REMOVE(print_db_head, p); SAFE_FREE(p); return NULL; } fstrcpy(p->printer_name, printername); return p; } static struct tdb_print_db *get_print_db_byjobid( uint32 jobid) { const char *printername = get_printer_name_byjobid(jobid); if (!printername) return NULL; return get_print_db_byname(printername); } /**************************************************************************** Initialise the printing backend. Called once at startup. Does not survive a fork ****************************************************************************/ BOOL print_backend_init(void) { struct printer_queueid_map *p; char *sversion = "INFO/version"; pstring printing_path; if (local_pid == sys_getpid()) return True; unlink(lock_path("printing.tdb")); pstrcpy(printing_path,lock_path("printing")); mkdir(printing_path,0755); local_pid = sys_getpid(); /* handle a Samba upgrade */ for (p = printer_queueid_map_head; p; p = p->next) { struct tdb_print_db *pdb = get_print_db_byname(p->printername); if (!pdb) continue; tdb_lock_bystring(pdb->tdb, sversion); if (tdb_fetch_int32(pdb->tdb, sversion) != PRINT_DATABASE_VERSION) { tdb_traverse(pdb->tdb, tdb_traverse_delete_fn, NULL); tdb_store_int32(pdb->tdb, sversion, PRINT_DATABASE_VERSION); } tdb_unlock_bystring(pdb->tdb, sversion); } /* select the appropriate printing interface... */ #ifdef HAVE_CUPS if (strcmp(lp_printcapname(), "cups") == 0) current_printif = &cups_printif; #endif /* HAVE_CUPS */ /* do NT print initialization... */ return nt_printing_init(); } /**************************************************************************** Shut down printing backend. Called once at shutdown to close the tdb. ****************************************************************************/ void printing_end(void) { struct tdb_print_db *p; for (p = print_db_head; p; ) { struct tdb_print_db *next_p = p->next; if (p->tdb) tdb_close(p->tdb); DLIST_REMOVE(print_db_head, p); SAFE_FREE(p); p = next_p; } } /**************************************************************************** Useful function to generate a tdb key. ****************************************************************************/ static TDB_DATA print_key(uint32 jobid) { static uint32 j; TDB_DATA ret; j = jobid; ret.dptr = (void *)&j; ret.dsize = sizeof(j); return ret; } /**************************************************************************** Useful function to find a print job in the database. ****************************************************************************/ static struct printjob *print_job_find(uint32 jobid) { static struct printjob pjob; TDB_DATA ret; struct tdb_print_db *pdb = get_print_db_byjobid(jobid); if (!pdb) return NULL; ret = tdb_fetch(pdb->tdb, print_key(jobid)); if (!ret.dptr || ret.dsize != sizeof(pjob)) return NULL; memcpy(&pjob, ret.dptr, sizeof(pjob)); SAFE_FREE(ret.dptr); return &pjob; } /* Convert a unix jobid to a smb jobid */ static uint32 sysjob_to_jobid_value; static int unixjob_traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA key, TDB_DATA data, void *state) { struct printjob *pjob = (struct printjob *)data.dptr; int *sysjob = (int *)state; if (key.dsize != sizeof(uint32)) return 0; if (*sysjob == pjob->sysjob) { uint32 *jobid = (uint32 *)key.dptr; sysjob_to_jobid_value = *jobid; return 1; } return 0; } /**************************************************************************** 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 sysjob_to_jobid(int unix_jobid) { struct printer_queueid_map *p; sysjob_to_jobid_value = (uint32)-1; for (p = printer_queueid_map_head; p; p = p->next) { struct tdb_print_db *pdb = get_print_db_byname(p->printername); if (pdb) tdb_traverse(pdb->tdb, unixjob_traverse_fn, &unix_jobid); if (sysjob_to_jobid_value != (uint32)-1) return sysjob_to_jobid_value; } return (uint32)-1; } /**************************************************************************** Send notifications based on what has changed after a pjob_store. ****************************************************************************/ static struct { uint32 lpq_status; uint32 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 }, { LPQ_USER_INTERVENTION, JOB_STATUS_USER_INTERVENTION }, { -1, 0 } }; /* Convert a lpq status value stored in printing.tdb into the appropriate win32 API constant. */ static uint32 map_to_spoolss_status(uint32 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; } static void pjob_store_notify(uint32 jobid, struct printjob *old_data, struct printjob *new_data) { BOOL new_job = False; int snum = print_job_snum(jobid); if (snum == -1) return; if (!old_data) new_job = True; /* Notify the job name first */ if (new_job || !strequal(old_data->jobname, new_data->jobname)) notify_job_name(snum, jobid, new_data->jobname); /* Job attributes that can't be changed. We only send notification for these on a new job. */ if (new_job) { notify_job_submitted(snum, jobid, new_data->starttime); notify_job_username(snum, jobid, new_data->user); } /* Job attributes of a new job or attributes that can be modified. */ if (new_job || old_data->status != new_data->status) notify_job_status(snum, jobid, map_to_spoolss_status(new_data->status)); if (new_job || old_data->size != new_data->size) notify_job_total_bytes(snum, jobid, new_data->size); if (new_job || old_data->page_count != new_data->page_count) notify_job_total_pages(snum, jobid, new_data->page_count); } /**************************************************************************** Store a job structure back to the database. ****************************************************************************/ static BOOL pjob_store(uint32 jobid, struct printjob *pjob) { TDB_DATA old_data, new_data; BOOL ret; struct tdb_print_db *pdb = get_print_db_byjobid(jobid); if (!pdb) return False; /* Get old data */ old_data = tdb_fetch(pdb->tdb, print_key(jobid)); /* Store new data */ new_data.dptr = (void *)pjob; new_data.dsize = sizeof(*pjob); ret = (tdb_store(pdb->tdb, print_key(jobid), new_data, TDB_REPLACE) == 0); /* Send notify updates for what has changed */ if (ret && (old_data.dsize == 0 || old_data.dsize == sizeof(*pjob))) { pjob_store_notify( jobid, (struct printjob *)old_data.dptr, (struct printjob *)new_data.dptr); free(old_data.dptr); } return ret; } /**************************************************************************** Remove a job structure from the database. ****************************************************************************/ static void pjob_delete(uint32 jobid) { int snum; struct printjob *pjob = print_job_find(jobid); uint32 job_status = 0; struct tdb_print_db *pdb = get_print_db_byjobid(jobid); if (!pdb) return; if (!pjob) { DEBUG(5, ("pjob_delete(): we were asked to delete nonexistent job %u\n", (unsigned int)jobid)); return; } /* Send a notification that a job has been deleted */ job_status = map_to_spoolss_status(pjob->status); /* We must cycle through JOB_STATUS_DELETING and JOB_STATUS_DELETED for the port monitor to delete the job properly. */ snum = print_job_snum(jobid); job_status |= JOB_STATUS_DELETING; notify_job_status(snum, jobid, job_status); job_status |= JOB_STATUS_DELETED; notify_job_status(snum, jobid, job_status); /* Remove from printing.tdb */ tdb_delete(pdb->tdb, print_key(jobid)); rap_jobid_delete(jobid); } /**************************************************************************** Parse a file name from the system spooler to generate a jobid. ****************************************************************************/ static uint32 print_parse_jobid(char *fname) { int jobid; if (strncmp(fname,PRINT_SPOOL_PREFIX,strlen(PRINT_SPOOL_PREFIX)) != 0) return (uint32)-1; fname += strlen(PRINT_SPOOL_PREFIX); jobid = atoi(fname); if (jobid <= 0) return (uint32)-1; return (uint32)jobid; } /**************************************************************************** List a unix job in the print database. ****************************************************************************/ static void print_unix_job(int snum, print_queue_struct *q) { uint32 queueid = get_printer_queueid_byname(PRINTERNAME(snum)); uint32 jobid = (q->job + UNIX_JOB_START) | QUEUEID_TO_JOBID(queueid); struct printjob pj, *old_pj; /* Preserve the timestamp on an existing unix print job */ old_pj = print_job_find(jobid); ZERO_STRUCT(pj); pj.pid = (pid_t)-1; pj.sysjob = q->job; pj.fd = -1; pj.starttime = old_pj ? old_pj->starttime : q->time; pj.status = q->status; pj.size = q->size; pj.spooled = True; pj.smbjob = False; fstrcpy(pj.filename, ""); fstrcpy(pj.jobname, q->fs_file); fstrcpy(pj.user, q->fs_user); fstrcpy(pj.queuename, lp_const_servicename(snum)); pjob_store(jobid, &pj); } struct traverse_struct { print_queue_struct *queue; int qcount, snum, maxcount, total_jobs; }; /**************************************************************************** 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) { uint32 queueid; struct traverse_struct *ts = (struct traverse_struct *)state; struct printjob pjob; uint32 jobid; int i; if (data.dsize != sizeof(pjob) || key.dsize != sizeof(jobid)) return 0; memcpy(&jobid, key.dptr, sizeof(jobid)); memcpy(&pjob, data.dptr, sizeof(pjob)); if (ts->snum != lp_servicenumber(pjob.queuename)) { /* this isn't for the queue we are looking at - this cannot happen with the split tdb's. JRA */ return 0; } queueid = get_printer_queueid_byname(pjob.queuename); if (!pjob.smbjob) { /* remove a unix job if it isn't in the system queue any more */ for (i=0;iqcount;i++) { uint32 u_jobid = ((ts->queue[i].job + UNIX_JOB_START) | QUEUEID_TO_JOBID(queueid)); if (jobid == u_jobid) break; } if (i == ts->qcount) pjob_delete(jobid); else ts->total_jobs++; return 0; } /* 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(pjob.pid)) pjob_delete(jobid); else ts->total_jobs++; return 0; } for (i=0;iqcount;i++) { uint32 curr_jobid = print_parse_jobid(ts->queue[i].fs_file) | QUEUEID_TO_JOBID(queueid); if (jobid == curr_jobid) 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) { time_t cur_t = time(NULL); /* 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. A workaround is to not delete the job if it has been submitted less than lp_lpqcachetime() seconds ago. */ if ((cur_t - pjob.starttime) > lp_lpqcachetime()) pjob_delete(jobid); else ts->total_jobs++; } else ts->total_jobs++; return 0; } /**************************************************************************** Check if the print queue has been updated recently enough. ****************************************************************************/ static void print_cache_flush(int snum) { fstring key; const char *printername = lp_const_servicename(snum); struct tdb_print_db *pdb = get_print_db_byname(printername); if (!pdb) return; slprintf(key, sizeof(key)-1, "CACHE/%s", printername); tdb_store_int32(pdb->tdb, key, -1); } /**************************************************************************** Check if someone already thinks they are doing the update. ****************************************************************************/ static pid_t get_updating_pid(fstring printer_name) { fstring keystr; TDB_DATA data, key; pid_t updating_pid; struct tdb_print_db *pdb = get_print_db_byname(printer_name); if (!pdb) return (pid_t)-1; slprintf(keystr, sizeof(keystr)-1, "UPDATING/%s", printer_name); key.dptr = keystr; key.dsize = strlen(keystr); data = tdb_fetch(pdb->tdb, key); if (!data.dptr || data.dsize != sizeof(pid_t)) return (pid_t)-1; memcpy(&updating_pid, data.dptr, sizeof(pid_t)); SAFE_FREE(data.dptr); if (process_exists(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(fstring printer_name, BOOL delete) { fstring keystr; TDB_DATA key; TDB_DATA data; pid_t updating_pid = sys_getpid(); struct tdb_print_db *pdb = get_print_db_byname(printer_name); if (!pdb) return; slprintf(keystr, sizeof(keystr)-1, "UPDATING/%s", printer_name); key.dptr = keystr; key.dsize = strlen(keystr); if (delete) { tdb_delete(pdb->tdb, key); return; } data.dptr = (void *)&updating_pid; data.dsize = sizeof(pid_t); tdb_store(pdb->tdb, key, data, TDB_REPLACE); } /**************************************************************************** Update the internal database from the system print queue for a queue. ****************************************************************************/ static void print_queue_update(int snum) { int i, qcount; print_queue_struct *queue = NULL; print_status_struct status; print_status_struct old_status; struct printjob *pjob; struct traverse_struct tstruct; fstring keystr, printer_name, cachestr; TDB_DATA data, key; struct tdb_print_db *pdb; fstrcpy(printer_name, lp_const_servicename(snum)); pdb = get_print_db_byname(printer_name); if (!pdb) return; /* * Check to see if someone else is doing this update. * This is essentially a mutex on the update. */ if (get_updating_pid(printer_name) != -1) return; /* Lock the queue for the database update */ slprintf(keystr, sizeof(keystr) - 1, "LOCK/%s", printer_name); tdb_lock_bystring(pdb->tdb, keystr); /* * Ensure that no one else got in here. * If the updating pid is still -1 then we are * the winner. */ if (get_updating_pid(printer_name) != -1) { /* * Someone else is doing the update, exit. */ tdb_unlock_bystring(pdb->tdb, keystr); return; } /* * We're going to do the update ourselves. */ /* Tell others we're doing the update. */ set_updating_pid(printer_name, False); /* * Allow others to enter and notice we're doing * the update. */ tdb_unlock_bystring(pdb->tdb, keystr); /* * 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", printer_name); 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))(snum, &queue, &status); DEBUG(3, ("%d job%s in queue for %s\n", qcount, (qcount != 1) ? "s" : "", printer_name)); /* 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 */ for (i=0; isysjob = queue[i].job; pjob->status = queue[i].status; pjob_store(jobid, pjob); } /* now delete any queued entries that don't appear in the system queue */ tstruct.queue = queue; tstruct.qcount = qcount; tstruct.snum = snum; tstruct.total_jobs = 0; tdb_traverse(pdb->tdb, traverse_fn_delete, (void *)&tstruct); SAFE_FREE(tstruct.queue); tdb_store_int32(pdb->tdb, "INFO/total_jobs", tstruct.total_jobs); if( qcount != get_queue_status(snum, &old_status)) DEBUG(10,("print_queue_update: queue status change %d jobs -> %d jobs for printer %s\n", old_status.qcount, qcount, printer_name )); /* store the new queue status structure */ slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", printer_name); key.dptr = keystr; key.dsize = strlen(keystr); status.qcount = qcount; data.dptr = (void *)&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", printer_name); tdb_store_int32(pdb->tdb, keystr, (int32)time(NULL)); /* Delete our pid from the db. */ set_updating_pid(printer_name, True); } /**************************************************************************** Check if a jobid is valid. It is valid if it exists in the database. ****************************************************************************/ BOOL print_job_exists(uint32 jobid) { struct tdb_print_db *pdb = get_print_db_byjobid(jobid); if (!pdb) return False; return tdb_exists(pdb->tdb, print_key(jobid)); } /**************************************************************************** Work out which service a jobid is for. Note that we have to look up by queue name to ensure that it works for other than the process that started the job. ****************************************************************************/ int print_job_snum(uint32 jobid) { struct printjob *pjob = print_job_find(jobid); if (!pjob) return -1; return find_service(pjob->queuename); } /**************************************************************************** Give the fd used for a jobid. ****************************************************************************/ int print_job_fd(uint32 jobid) { struct printjob *pjob = print_job_find(jobid); if (!pjob) return -1; /* don't allow another process to get this info - it is meaningless */ if (pjob->pid != local_pid) return -1; return pjob->fd; } /**************************************************************************** Give the filename used for a jobid. Only valid for the process doing the spooling and when the job has not been spooled. ****************************************************************************/ char *print_job_fname(uint32 jobid) { struct printjob *pjob = print_job_find(jobid); if (!pjob || pjob->spooled || pjob->pid != local_pid) return NULL; return pjob->filename; } /**************************************************************************** Set the place in the queue for a job. ****************************************************************************/ BOOL print_job_set_place(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(uint32 jobid, char *name) { struct printjob *pjob = print_job_find(jobid); if (!pjob || pjob->pid != local_pid) return False; fstrcpy(pjob->jobname, name); return pjob_store(jobid, pjob); } /**************************************************************************** Delete a print job - don't update queue. ****************************************************************************/ static BOOL print_job_delete1(uint32 jobid) { struct printjob *pjob = print_job_find(jobid); int snum, result = 0; if (!pjob) return False; /* * If already deleting just return. */ if (pjob->status == LPQ_DELETING) return True; snum = print_job_snum(jobid); if (snum == -1) { DEBUG(5,("print_job_delete1: unknown service number for jobid %u\n", (unsigned int)jobid)); return False; } /* Hrm - we need to be able to cope with deleting a job before it has reached the spooler. */ 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(jobid, pjob); if (pjob->spooled && pjob->sysjob != -1) result = (*(current_printif->job_delete))(snum, pjob); /* Delete the tdb entry if the delete suceeded or the job hasn't been spooled. */ if (result == 0) pjob_delete(jobid); return (result == 0); } /**************************************************************************** Return true if the current user owns the print job. ****************************************************************************/ static BOOL is_owner(struct current_user *user, uint32 jobid) { struct printjob *pjob = print_job_find(jobid); user_struct *vuser; if (!pjob || !user) return False; if ((vuser = get_valid_user_struct(user->vuid)) != NULL) { return strequal(pjob->user, vuser->user.smb_name); } else { return strequal(pjob->user, uidtoname(user->uid)); } } /**************************************************************************** Delete a print job. ****************************************************************************/ BOOL print_job_delete(struct current_user *user, uint32 jobid, WERROR *errcode) { int snum = print_job_snum(jobid); BOOL owner; if (snum == -1) { DEBUG(5,("print_job_delete: unknown service number for jobid %d\n", jobid)); return False; } owner = is_owner(user, jobid); /* Check access against security descriptor or whether the user owns their job. */ if (!owner && !print_access_check(user, snum, JOB_ACCESS_ADMINISTER)) { DEBUG(3, ("delete denied by security descriptor\n")); *errcode = WERR_ACCESS_DENIED; return False; } if (!print_job_delete1(jobid)) return False; /* force update the database and say the delete failed if the job still exists */ print_queue_update(snum); return !print_job_exists(jobid); } /**************************************************************************** Pause a job. ****************************************************************************/ BOOL print_job_pause(struct current_user *user, uint32 jobid, WERROR *errcode) { struct printjob *pjob = print_job_find(jobid); int snum, ret = -1; if (!pjob || !user) return False; if (!pjob->spooled || pjob->sysjob == -1) return False; snum = print_job_snum(jobid); if (snum == -1) { DEBUG(5,("print_job_pause: unknown service number for jobid %u\n", (unsigned int)jobid)); return False; } if (!is_owner(user, jobid) && !print_access_check(user, snum, JOB_ACCESS_ADMINISTER)) { DEBUG(3, ("pause denied by security descriptor\n")); *errcode = WERR_ACCESS_DENIED; return False; } /* need to pause the spooled entry */ ret = (*(current_printif->job_pause))(snum, pjob); if (ret != 0) { *errcode = WERR_INVALID_PARAM; return False; } /* force update the database */ print_cache_flush(snum); /* Send a printer notify message */ notify_job_status(snum, jobid, JOB_STATUS_PAUSED); /* how do we tell if this succeeded? */ return True; } /**************************************************************************** Resume a job. ****************************************************************************/ BOOL print_job_resume(struct current_user *user, uint32 jobid, WERROR *errcode) { struct printjob *pjob = print_job_find(jobid); int snum, ret; if (!pjob || !user) return False; if (!pjob->spooled || pjob->sysjob == -1) return False; snum = print_job_snum(jobid); if (snum == -1) { DEBUG(5,("print_job_resume: unknown service number for jobid %u\n", (unsigned int)jobid)); return False; } if (!is_owner(user, jobid) && !print_access_check(user, snum, JOB_ACCESS_ADMINISTER)) { DEBUG(3, ("resume denied by security descriptor\n")); *errcode = WERR_ACCESS_DENIED; return False; } ret = (*(current_printif->job_resume))(snum, pjob); if (ret != 0) { *errcode = WERR_INVALID_PARAM; return False; } /* force update the database */ print_cache_flush(snum); /* Send a printer notify message */ notify_job_status(snum, jobid, JOB_STATUS_QUEUED); return True; } /**************************************************************************** Write to a print file. ****************************************************************************/ int print_job_write(uint32 jobid, const char *buf, int size) { int return_code; struct printjob *pjob = print_job_find(jobid); if (!pjob) return -1; /* don't allow another process to get this info - it is meaningless */ if (pjob->pid != local_pid) return -1; return_code = write(pjob->fd, buf, size); if (return_code>0) { pjob->size += size; pjob_store(jobid, pjob); } return return_code; } /**************************************************************************** Check if the print queue has been updated recently enough. ****************************************************************************/ static BOOL print_cache_expired(int snum) { fstring key; time_t last_qscan_time, time_now = time(NULL); const char *printername = lp_const_servicename(snum); struct tdb_print_db *pdb = get_print_db_byname(printername); if (!pdb) return False; slprintf(key, sizeof(key), "CACHE/%s", printername); 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_lpqcachetime() || last_qscan_time > (time_now + MAX_CACHE_VALID_TIME)) { DEBUG(3, ("print cache expired for queue %s \ (last_qscan_time = %d, time now = %d, qcachetime = %d)\n", printername, (int)last_qscan_time, (int)time_now, (int)lp_lpqcachetime() )); return True; } return False; } /**************************************************************************** Get the queue status - do not update if db is out of date. ****************************************************************************/ static int get_queue_status(int snum, print_status_struct *status) { fstring keystr; TDB_DATA data, key; const char *printername = lp_const_servicename(snum); struct tdb_print_db *pdb = get_print_db_byname(printername); if (!pdb) return 0; ZERO_STRUCTP(status); slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", printername); key.dptr = keystr; key.dsize = strlen(keystr); data = tdb_fetch(pdb->tdb, key); if (data.dptr) { if (data.dsize == sizeof(print_status_struct)) { memcpy(status, data.dptr, sizeof(print_status_struct)); } SAFE_FREE(data.dptr); } return status->qcount; } /**************************************************************************** Determine the number of jobs in a queue. ****************************************************************************/ int print_queue_length(int snum, print_status_struct *pstatus) { print_status_struct status; int len; /* make sure the database is up to date */ if (print_cache_expired(snum)) print_queue_update(snum); /* also fetch the queue status */ memset(&status, 0, sizeof(status)); len = get_queue_status(snum, &status); if (pstatus) *pstatus = status; return len; } /**************************************************************************** Determine the number of jobs in all queues. This is very expensive. Don't call ! JRA. ****************************************************************************/ static int get_total_jobs(void) { int total_jobs; struct printer_queueid_map *p; for (p = printer_queueid_map_head; p; p = p->next) { int jobs; struct tdb_print_db *pdb = get_print_db_byname(p->printername); if (!pdb) continue; /* make sure the database is up to date */ if (print_cache_expired(lp_servicenumber(p->printername))) print_queue_update(lp_servicenumber(p->printername)); jobs = tdb_fetch_int32(pdb->tdb, "INFO/total_jobs"); if (jobs > 0) total_jobs += jobs; } return total_jobs; } /*************************************************************************** Start spooling a job - return the jobid. ***************************************************************************/ uint32 print_job_start(struct current_user *user, int snum, char *jobname) { uint32 jobid; char *path; struct printjob pjob; int next_jobid; user_struct *vuser; int njobs = 0; const char *printername = lp_const_servicename(snum); struct tdb_print_db *pdb = get_print_db_byname(printername); uint32 queueid = queueid = get_printer_queueid_byname(printername); errno = 0; if (!pdb) return (uint32)-1; if (!print_access_check(user, snum, PRINTER_ACCESS_USE)) { DEBUG(3, ("print_job_start: job start denied by security descriptor\n")); return (uint32)-1; } if (!print_time_access_check(snum)) { DEBUG(3, ("print_job_start: job start denied by time check\n")); return (uint32)-1; } path = lp_pathname(snum); /* see if we have sufficient disk space */ if (lp_minprintspace(snum)) { SMB_BIG_UINT dspace, dsize; if (sys_fsusage(path, &dspace, &dsize) == 0 && dspace < 2*(SMB_BIG_UINT)lp_minprintspace(snum)) { DEBUG(3, ("print_job_start: disk space check failed.\n")); errno = ENOSPC; return (uint32)-1; } } /* for autoloaded printers, check that the printcap entry still exists */ if (lp_autoloaded(snum) && !pcap_printername_ok(lp_const_servicename(snum), NULL)) { DEBUG(3, ("print_job_start: printer name %s check failed.\n", lp_const_servicename(snum) )); errno = ENOENT; return (uint32)-1; } /* Insure the maximum queue size is not violated */ if (lp_maxprintjobs(snum) && (njobs = print_queue_length(snum,NULL)) > lp_maxprintjobs(snum)) { DEBUG(3, ("print_job_start: number of jobs (%d) larger than max printjobs per queue (%d).\n", njobs, lp_maxprintjobs(snum) )); errno = ENOSPC; return (uint32)-1; } /* Insure the maximum print jobs in the system is not violated */ if (lp_totalprintjobs() && get_total_jobs() > lp_totalprintjobs()) { DEBUG(3, ("print_job_start: number of jobs (%d) larger than max printjobs per system (%d).\n", njobs, lp_totalprintjobs() )); errno = ENOSPC; return (uint32)-1; } /* create the database entry */ ZERO_STRUCT(pjob); pjob.pid = local_pid; pjob.sysjob = -1; pjob.fd = -1; pjob.starttime = time(NULL); pjob.status = LPQ_SPOOLING; pjob.size = 0; pjob.spooled = False; pjob.smbjob = True; fstrcpy(pjob.jobname, jobname); if ((vuser = get_valid_user_struct(user->vuid)) != NULL) { fstrcpy(pjob.user, vuser->user.smb_name); } else { fstrcpy(pjob.user, uidtoname(user->uid)); } fstrcpy(pjob.queuename, lp_const_servicename(snum)); /* lock the database */ tdb_lock_bystring(pdb->tdb, "INFO/nextjob"); next_jobid = tdb_fetch_int32(pdb->tdb, "INFO/nextjob"); if (next_jobid == -1) next_jobid = 1; for (jobid = NEXT_JOBID(next_jobid); jobid != next_jobid; jobid = NEXT_JOBID(jobid)) { if (!print_job_exists(jobid | QUEUEID_TO_JOBID(queueid))) break; } if (jobid == next_jobid || !pjob_store(jobid | QUEUEID_TO_JOBID(queueid), &pjob)) { DEBUG(3, ("print_job_start: either jobid (%d)==next_jobid(%d) or pjob_store failed.\n", jobid, next_jobid )); jobid = -1; goto fail; } if (tdb_store_int32(pdb->tdb, "INFO/nextjob", jobid)==-1) { DEBUG(3, ("print_job_start: failed to store INFO/nextjob.\n")); jobid = -1; goto fail; } /* Ensure the queuid is added to the jobid. */ jobid |= QUEUEID_TO_JOBID(queueid); /* we have a job entry - now create the spool file */ slprintf(pjob.filename, sizeof(pjob.filename)-1, "%s/%s%.8u.XXXXXX", path, PRINT_SPOOL_PREFIX, (unsigned int)jobid); pjob.fd = smb_mkstemp(pjob.filename); if (pjob.fd == -1) { if (errno == EACCES) { /* Common setup error, force a report. */ DEBUG(0, ("print_job_start: insufficient permissions \ to open spool file %s.\n", pjob.filename)); } else { /* Normal case, report at level 3 and above. */ DEBUG(3, ("print_job_start: can't open spool file %s,\n", pjob.filename)); DEBUGADD(3, ("errno = %d (%s).\n", errno, strerror(errno))); } goto fail; } pjob_store(jobid, &pjob); tdb_unlock_bystring(pdb->tdb, "INFO/nextjob"); /* * If the printer is marked as postscript output a leading * file identifier to ensure the file is treated as a raw * postscript file. * This has a similar effect as CtrlD=0 in WIN.INI file. * tim@fsg.com 09/06/94 */ if (lp_postscript(snum)) { print_job_write(jobid, "%!\n",3); } return jobid; fail: if (jobid != -1) pjob_delete(jobid); tdb_unlock_bystring(pdb->tdb, "INFO/nextjob"); DEBUG(3, ("print_job_start: returning fail. Error = %s\n", strerror(errno) )); return -1; } /**************************************************************************** Update the number of pages spooled to jobid ****************************************************************************/ void print_job_endpage(uint32 jobid) { struct printjob *pjob = print_job_find(jobid); if (!pjob) return; /* don't allow another process to get this info - it is meaningless */ if (pjob->pid != local_pid) return; pjob->page_count++; pjob_store(jobid, pjob); } /**************************************************************************** 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. ****************************************************************************/ BOOL print_job_end(uint32 jobid, BOOL normal_close) { struct printjob *pjob = print_job_find(jobid); int snum, ret; SMB_STRUCT_STAT sbuf; if (!pjob) return False; if (pjob->spooled || pjob->pid != local_pid) return False; snum = print_job_snum(jobid); if (snum == -1) { DEBUG(5,("print_job_end: unknown service number for jobid %u\n", (unsigned int)jobid)); return False; } if (normal_close && (sys_fstat(pjob->fd, &sbuf) == 0)) { pjob->size = sbuf.st_size; close(pjob->fd); pjob->fd = -1; } else { /* * Not a normal close or we couldn't stat the job file, * so something has gone wrong. Cleanup. */ close(pjob->fd); pjob->fd = -1; DEBUG(3,("print_job_end: failed to stat file for jobid %d\n", jobid )); 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(jobid); return True; } ret = (*(current_printif->job_submit))(snum, pjob); if (ret) goto fail; /* The print job has been sucessfully handed over to the back-end */ pjob->spooled = True; pjob->status = LPQ_QUEUED; pjob_store(jobid, pjob); /* make sure the database is up to date */ if (print_cache_expired(snum)) print_queue_update(snum); return True; fail: /* The print job was not succesfully started. Cleanup */ /* Still need to add proper error return propagation! 010122:JRR */ unlink(pjob->filename); pjob_delete(jobid); return False; } /**************************************************************************** Utility fn to enumerate the print queue. ****************************************************************************/ static int traverse_fn_queue(TDB_CONTEXT *t, TDB_DATA key, TDB_DATA data, void *state) { struct traverse_struct *ts = (struct traverse_struct *)state; struct printjob pjob; int i; uint32 jobid; if (data.dsize != sizeof(pjob) || key.dsize != sizeof(int)) return 0; memcpy(&jobid, key.dptr, sizeof(jobid)); memcpy(&pjob, data.dptr, sizeof(pjob)); /* maybe it isn't for this queue */ if (ts->snum != lp_servicenumber(pjob.queuename)) return 0; if (ts->qcount >= ts->maxcount) return 0; i = ts->qcount; ts->queue[i].job = jobid; 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->qcount++; return 0; } struct traverse_count_struct { int snum, count; }; /**************************************************************************** Utility fn to count the number of entries in the print queue. ****************************************************************************/ static int traverse_count_fn_queue(TDB_CONTEXT *t, TDB_DATA key, TDB_DATA data, void *state) { struct traverse_count_struct *ts = (struct traverse_count_struct *)state; struct printjob pjob; uint32 jobid; if (data.dsize != sizeof(pjob) || key.dsize != sizeof(int)) return 0; memcpy(&jobid, key.dptr, sizeof(jobid)); memcpy(&pjob, data.dptr, sizeof(pjob)); /* maybe it isn't for this queue - this cannot happen with the tdb/printer code. JRA */ if (ts->snum != lp_servicenumber(pjob.queuename)) return 0; ts->count++; return 0; } /**************************************************************************** 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; } /**************************************************************************** Get a printer queue listing. ****************************************************************************/ int print_queue_status(int snum, print_queue_struct **queue, print_status_struct *status) { struct traverse_struct tstruct; struct traverse_count_struct tsc; fstring keystr; TDB_DATA data, key; const char *printername = lp_const_servicename(snum); struct tdb_print_db *pdb = get_print_db_byname(printername); *queue = NULL; if (!pdb) return 0; /* make sure the database is up to date */ if (print_cache_expired(snum)) print_queue_update(snum); /* * 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", printername); key.dptr = keystr; key.dsize = strlen(keystr); data = tdb_fetch(pdb->tdb, key); if (data.dptr) { if (data.dsize == sizeof(*status)) { 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. */ tsc.count = 0; tsc.snum = snum; tdb_traverse(pdb->tdb, traverse_count_fn_queue, (void *)&tsc); if (tsc.count == 0) return 0; /* Allocate the queue size. */ if ((tstruct.queue = (print_queue_struct *) malloc(sizeof(print_queue_struct)*tsc.count)) == NULL) return 0; /* * Fill in the queue. * We need maxcount as the queue size may have changed between * the two calls to tdb_traverse. */ tstruct.qcount = 0; tstruct.maxcount = tsc.count; tstruct.snum = snum; tdb_traverse(pdb->tdb, traverse_fn_queue, (void *)&tstruct); /* Sort the queue by submission time otherwise they are displayed in hash order. */ qsort(tstruct.queue, tstruct.qcount, sizeof(print_queue_struct), QSORT_CAST(printjob_comp)); *queue = tstruct.queue; return tstruct.qcount; } /**************************************************************************** Turn a queue name into a snum. ****************************************************************************/ int print_queue_snum(const char *qname) { int snum = lp_servicenumber(qname); if (snum == -1 || !lp_print_ok(snum)) return -1; return snum; } /**************************************************************************** Pause a queue. ****************************************************************************/ BOOL print_queue_pause(struct current_user *user, int snum, WERROR *errcode) { int ret; if (!print_access_check(user, snum, PRINTER_ACCESS_ADMINISTER)) { *errcode = WERR_ACCESS_DENIED; return False; } ret = (*(current_printif->queue_pause))(snum); if (ret != 0) { *errcode = WERR_INVALID_PARAM; return False; } /* force update the database */ print_cache_flush(snum); /* Send a printer notify message */ notify_printer_status(snum, PRINTER_STATUS_PAUSED); return True; } /**************************************************************************** Resume a queue. ****************************************************************************/ BOOL print_queue_resume(struct current_user *user, int snum, WERROR *errcode) { int ret; if (!print_access_check(user, snum, PRINTER_ACCESS_ADMINISTER)) { *errcode = WERR_ACCESS_DENIED; return False; } ret = (*(current_printif->queue_resume))(snum); if (ret != 0) { *errcode = WERR_INVALID_PARAM; return False; } /* make sure the database is up to date */ if (print_cache_expired(snum)) print_queue_update(snum); /* Send a printer notify message */ notify_printer_status(snum, PRINTER_STATUS_OK); return True; } /**************************************************************************** Purge a queue - implemented by deleting all jobs that we can delete. ****************************************************************************/ 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; /* Force and update so the count is accurate (i.e. not a cached count) */ print_queue_update(snum); can_job_admin = print_access_check(user, snum, JOB_ACCESS_ADMINISTER); njobs = print_queue_status(snum, &queue, &status); for (i=0;i