4051a6ca3422b19ac9057a1e1b02f2ed46972562
[kai/samba.git] / source3 / printing / printing.c
1 /* 
2    Unix SMB/Netbios implementation.
3    Version 3.0
4    printing backend routines
5    Copyright (C) Andrew Tridgell 1992-2000
6    Copyright (C) Jeremy Allison 2002
7    
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "printing.h"
24
25 extern SIG_ATOMIC_T got_sig_term;
26 extern SIG_ATOMIC_T reload_after_sighup;
27 extern struct current_user current_user;
28 extern userdom_struct current_user_info;
29
30 /* Current printer interface */
31 static bool remove_from_jobs_changed(const char* sharename, uint32 jobid);
32
33 /* 
34    the printing backend revolves around a tdb database that stores the
35    SMB view of the print queue 
36    
37    The key for this database is a jobid - a internally generated number that
38    uniquely identifies a print job
39
40    reading the print queue involves two steps:
41      - possibly running lpq and updating the internal database from that
42      - reading entries from the database
43
44    jobids are assigned when a job starts spooling. 
45 */
46
47 static TDB_CONTEXT *rap_tdb;
48 static uint16 next_rap_jobid;
49 struct rap_jobid_key {
50         fstring sharename;
51         uint32  jobid;
52 };
53
54 /***************************************************************************
55  Nightmare. LANMAN jobid's are 16 bit numbers..... We must map them to 32
56  bit RPC jobids.... JRA.
57 ***************************************************************************/
58
59 uint16 pjobid_to_rap(const char* sharename, uint32 jobid)
60 {
61         uint16 rap_jobid;
62         TDB_DATA data, key;
63         struct rap_jobid_key jinfo;
64         uint8 buf[2];
65
66         DEBUG(10,("pjobid_to_rap: called.\n"));
67
68         if (!rap_tdb) {
69                 /* Create the in-memory tdb. */
70                 rap_tdb = tdb_open_log(NULL, 0, TDB_INTERNAL, (O_RDWR|O_CREAT), 0644);
71                 if (!rap_tdb)
72                         return 0;
73         }
74
75         ZERO_STRUCT( jinfo );
76         fstrcpy( jinfo.sharename, sharename );
77         jinfo.jobid = jobid;
78         key.dptr = (uint8 *)&jinfo;
79         key.dsize = sizeof(jinfo);
80
81         data = tdb_fetch(rap_tdb, key);
82         if (data.dptr && data.dsize == sizeof(uint16)) {
83                 rap_jobid = SVAL(data.dptr, 0);
84                 SAFE_FREE(data.dptr);
85                 DEBUG(10,("pjobid_to_rap: jobid %u maps to RAP jobid %u\n",
86                         (unsigned int)jobid, (unsigned int)rap_jobid));
87                 return rap_jobid;
88         }
89         SAFE_FREE(data.dptr);
90         /* Not found - create and store mapping. */
91         rap_jobid = ++next_rap_jobid;
92         if (rap_jobid == 0)
93                 rap_jobid = ++next_rap_jobid;
94         SSVAL(buf,0,rap_jobid);
95         data.dptr = buf;
96         data.dsize = sizeof(rap_jobid);
97         tdb_store(rap_tdb, key, data, TDB_REPLACE);
98         tdb_store(rap_tdb, data, key, TDB_REPLACE);
99
100         DEBUG(10,("pjobid_to_rap: created jobid %u maps to RAP jobid %u\n",
101                 (unsigned int)jobid, (unsigned int)rap_jobid));
102         return rap_jobid;
103 }
104
105 bool rap_to_pjobid(uint16 rap_jobid, fstring sharename, uint32 *pjobid)
106 {
107         TDB_DATA data, key;
108         uint8 buf[2];
109
110         DEBUG(10,("rap_to_pjobid called.\n"));
111
112         if (!rap_tdb)
113                 return False;
114
115         SSVAL(buf,0,rap_jobid);
116         key.dptr = buf;
117         key.dsize = sizeof(rap_jobid);
118         data = tdb_fetch(rap_tdb, key);
119         if ( data.dptr && data.dsize == sizeof(struct rap_jobid_key) ) 
120         {
121                 struct rap_jobid_key *jinfo = (struct rap_jobid_key*)data.dptr;
122                 fstrcpy( sharename, jinfo->sharename );
123                 *pjobid = jinfo->jobid;
124                 DEBUG(10,("rap_to_pjobid: jobid %u maps to RAP jobid %u\n",
125                         (unsigned int)*pjobid, (unsigned int)rap_jobid));
126                 SAFE_FREE(data.dptr);
127                 return True;
128         }
129
130         DEBUG(10,("rap_to_pjobid: Failed to lookup RAP jobid %u\n",
131                 (unsigned int)rap_jobid));
132         SAFE_FREE(data.dptr);
133         return False;
134 }
135
136 static void rap_jobid_delete(const char* sharename, uint32 jobid)
137 {
138         TDB_DATA key, data;
139         uint16 rap_jobid;
140         struct rap_jobid_key jinfo;
141         uint8 buf[2];
142
143         DEBUG(10,("rap_jobid_delete: called.\n"));
144
145         if (!rap_tdb)
146                 return;
147
148         ZERO_STRUCT( jinfo );
149         fstrcpy( jinfo.sharename, sharename );
150         jinfo.jobid = jobid;
151         key.dptr = (uint8 *)&jinfo;
152         key.dsize = sizeof(jinfo);
153
154         data = tdb_fetch(rap_tdb, key);
155         if (!data.dptr || (data.dsize != sizeof(uint16))) {
156                 DEBUG(10,("rap_jobid_delete: cannot find jobid %u\n",
157                         (unsigned int)jobid ));
158                 SAFE_FREE(data.dptr);
159                 return;
160         }
161
162         DEBUG(10,("rap_jobid_delete: deleting jobid %u\n",
163                 (unsigned int)jobid ));
164
165         rap_jobid = SVAL(data.dptr, 0);
166         SAFE_FREE(data.dptr);
167         SSVAL(buf,0,rap_jobid);
168         data.dptr = buf;
169         data.dsize = sizeof(rap_jobid);
170         tdb_delete(rap_tdb, key);
171         tdb_delete(rap_tdb, data);
172 }
173
174 static int get_queue_status(const char* sharename, print_status_struct *);
175
176 /****************************************************************************
177  Initialise the printing backend. Called once at startup before the fork().
178 ****************************************************************************/
179
180 bool print_backend_init(struct messaging_context *msg_ctx)
181 {
182         const char *sversion = "INFO/version";
183         int services = lp_numservices();
184         int snum;
185
186         unlink(lock_path("printing.tdb"));
187         mkdir(lock_path("printing"),0755);
188
189         /* handle a Samba upgrade */
190
191         for (snum = 0; snum < services; snum++) {
192                 struct tdb_print_db *pdb;
193                 if (!lp_print_ok(snum))
194                         continue;
195
196                 pdb = get_print_db_byname(lp_const_servicename(snum));
197                 if (!pdb)
198                         continue;
199                 if (tdb_lock_bystring(pdb->tdb, sversion) == -1) {
200                         DEBUG(0,("print_backend_init: Failed to open printer %s database\n", lp_const_servicename(snum) ));
201                         release_print_db(pdb);
202                         return False;
203                 }
204                 if (tdb_fetch_int32(pdb->tdb, sversion) != PRINT_DATABASE_VERSION) {
205                         tdb_wipe_all(pdb->tdb);
206                         tdb_store_int32(pdb->tdb, sversion, PRINT_DATABASE_VERSION);
207                 }
208                 tdb_unlock_bystring(pdb->tdb, sversion);
209                 release_print_db(pdb);
210         }
211
212         close_all_print_db(); /* Don't leave any open. */
213
214         /* do NT print initialization... */
215         return nt_printing_init(msg_ctx);
216 }
217
218 /****************************************************************************
219  Shut down printing backend. Called once at shutdown to close the tdb.
220 ****************************************************************************/
221
222 void printing_end(void)
223 {
224         close_all_print_db(); /* Don't leave any open. */
225 }
226
227 /****************************************************************************
228  Retrieve the set of printing functions for a given service.  This allows 
229  us to set the printer function table based on the value of the 'printing'
230  service parameter.
231  
232  Use the generic interface as the default and only use cups interface only
233  when asked for (and only when supported)
234 ****************************************************************************/
235
236 static struct printif *get_printer_fns_from_type( enum printing_types type )
237 {
238         struct printif *printer_fns = &generic_printif;
239
240 #ifdef HAVE_CUPS
241         if ( type == PRINT_CUPS ) {
242                 printer_fns = &cups_printif;
243         }
244 #endif /* HAVE_CUPS */
245
246 #ifdef HAVE_IPRINT
247         if ( type == PRINT_IPRINT ) {
248                 printer_fns = &iprint_printif;
249         }
250 #endif /* HAVE_IPRINT */
251
252         printer_fns->type = type;
253         
254         return printer_fns;
255 }
256
257 static struct printif *get_printer_fns( int snum )
258 {
259         return get_printer_fns_from_type( (enum printing_types)lp_printing(snum) );
260 }
261
262
263 /****************************************************************************
264  Useful function to generate a tdb key.
265 ****************************************************************************/
266
267 static TDB_DATA print_key(uint32 jobid, uint32 *tmp)
268 {
269         TDB_DATA ret;
270
271         SIVAL(tmp, 0, jobid);
272         ret.dptr = (uint8 *)tmp;
273         ret.dsize = sizeof(*tmp);
274         return ret;
275 }
276
277 /***********************************************************************
278  unpack a pjob from a tdb buffer 
279 ***********************************************************************/
280  
281 int unpack_pjob( uint8 *buf, int buflen, struct printjob *pjob )
282 {
283         int     len = 0;
284         int     used;
285         uint32 pjpid, pjsysjob, pjfd, pjstarttime, pjstatus;
286         uint32 pjsize, pjpage_count, pjspooled, pjsmbjob;
287
288         if ( !buf || !pjob )
289                 return -1;
290                 
291         len += tdb_unpack(buf+len, buflen-len, "dddddddddffff",
292                                 &pjpid,
293                                 &pjsysjob,
294                                 &pjfd,
295                                 &pjstarttime,
296                                 &pjstatus,
297                                 &pjsize,
298                                 &pjpage_count,
299                                 &pjspooled,
300                                 &pjsmbjob,
301                                 pjob->filename,
302                                 pjob->jobname,
303                                 pjob->user,
304                                 pjob->queuename);
305                                 
306         if ( len == -1 )
307                 return -1;
308                 
309         if ( (used = unpack_devicemode(&pjob->nt_devmode, buf+len, buflen-len)) == -1 )
310                 return -1;
311         
312         len += used;
313
314         pjob->pid = pjpid;
315         pjob->sysjob = pjsysjob;
316         pjob->fd = pjfd;
317         pjob->starttime = pjstarttime;
318         pjob->status = pjstatus;
319         pjob->size = pjsize;
320         pjob->page_count = pjpage_count;
321         pjob->spooled = pjspooled;
322         pjob->smbjob = pjsmbjob;
323         
324         return len;
325
326 }
327
328 /****************************************************************************
329  Useful function to find a print job in the database.
330 ****************************************************************************/
331
332 static struct printjob *print_job_find(const char *sharename, uint32 jobid)
333 {
334         static struct printjob  pjob;
335         uint32_t tmp;
336         TDB_DATA                ret;
337         struct tdb_print_db     *pdb = get_print_db_byname(sharename);
338
339         DEBUG(10,("print_job_find: looking up job %u for share %s\n",
340                         (unsigned int)jobid, sharename ));
341
342         if (!pdb) {
343                 return NULL;
344         }
345
346         ret = tdb_fetch(pdb->tdb, print_key(jobid, &tmp));
347         release_print_db(pdb);
348
349         if (!ret.dptr) {
350                 DEBUG(10,("print_job_find: failed to find jobid %u.\n", (unsigned int)jobid ));
351                 return NULL;
352         }
353
354         if ( pjob.nt_devmode ) {
355                 free_nt_devicemode( &pjob.nt_devmode );
356         }
357
358         ZERO_STRUCT( pjob );
359
360         if ( unpack_pjob( ret.dptr, ret.dsize, &pjob ) == -1 ) {
361                 DEBUG(10,("print_job_find: failed to unpack jobid %u.\n", (unsigned int)jobid ));
362                 SAFE_FREE(ret.dptr);
363                 return NULL;
364         }
365
366         SAFE_FREE(ret.dptr);
367
368         DEBUG(10,("print_job_find: returning system job %d for jobid %u.\n",
369                         (int)pjob.sysjob, (unsigned int)jobid ));
370
371         return &pjob;
372 }
373
374 /* Convert a unix jobid to a smb jobid */
375
376 struct unixjob_traverse_state {
377         int sysjob;
378         uint32 sysjob_to_jobid_value;
379 };
380
381 static int unixjob_traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA key,
382                                TDB_DATA data, void *private_data)
383 {
384         struct printjob *pjob;
385         struct unixjob_traverse_state *state =
386                 (struct unixjob_traverse_state *)private_data;
387
388         if (!data.dptr || data.dsize == 0)
389                 return 0;
390
391         pjob = (struct printjob *)data.dptr;
392         if (key.dsize != sizeof(uint32))
393                 return 0;
394
395         if (state->sysjob == pjob->sysjob) {
396                 uint32 jobid = IVAL(key.dptr,0);
397
398                 state->sysjob_to_jobid_value = jobid;
399                 return 1;
400         }
401
402         return 0;
403 }
404
405 /****************************************************************************
406  This is a *horribly expensive call as we have to iterate through all the
407  current printer tdb's. Don't do this often ! JRA.
408 ****************************************************************************/
409
410 uint32 sysjob_to_jobid(int unix_jobid)
411 {
412         int services = lp_numservices();
413         int snum;
414         struct unixjob_traverse_state state;
415
416         state.sysjob = unix_jobid;
417         state.sysjob_to_jobid_value = (uint32)-1;
418
419         for (snum = 0; snum < services; snum++) {
420                 struct tdb_print_db *pdb;
421                 if (!lp_print_ok(snum))
422                         continue;
423                 pdb = get_print_db_byname(lp_const_servicename(snum));
424                 if (!pdb) {
425                         continue;
426                 }
427                 tdb_traverse(pdb->tdb, unixjob_traverse_fn, &state);
428                 release_print_db(pdb);
429                 if (state.sysjob_to_jobid_value != (uint32)-1)
430                         return state.sysjob_to_jobid_value;
431         }
432         return (uint32)-1;
433 }
434
435 /****************************************************************************
436  Send notifications based on what has changed after a pjob_store.
437 ****************************************************************************/
438
439 static const struct {
440         uint32 lpq_status;
441         uint32 spoolss_status;
442 } lpq_to_spoolss_status_map[] = {
443         { LPQ_QUEUED, JOB_STATUS_QUEUED },
444         { LPQ_PAUSED, JOB_STATUS_PAUSED },
445         { LPQ_SPOOLING, JOB_STATUS_SPOOLING },
446         { LPQ_PRINTING, JOB_STATUS_PRINTING },
447         { LPQ_DELETING, JOB_STATUS_DELETING },
448         { LPQ_OFFLINE, JOB_STATUS_OFFLINE },
449         { LPQ_PAPEROUT, JOB_STATUS_PAPEROUT },
450         { LPQ_PRINTED, JOB_STATUS_PRINTED },
451         { LPQ_DELETED, JOB_STATUS_DELETED },
452         { LPQ_BLOCKED, JOB_STATUS_BLOCKED },
453         { LPQ_USER_INTERVENTION, JOB_STATUS_USER_INTERVENTION },
454         { -1, 0 }
455 };
456
457 /* Convert a lpq status value stored in printing.tdb into the
458    appropriate win32 API constant. */
459
460 static uint32 map_to_spoolss_status(uint32 lpq_status)
461 {
462         int i = 0;
463
464         while (lpq_to_spoolss_status_map[i].lpq_status != -1) {
465                 if (lpq_to_spoolss_status_map[i].lpq_status == lpq_status)
466                         return lpq_to_spoolss_status_map[i].spoolss_status;
467                 i++;
468         }
469
470         return 0;
471 }
472
473 static void pjob_store_notify(const char* sharename, uint32 jobid, struct printjob *old_data,
474                               struct printjob *new_data)
475 {
476         bool new_job = False;
477
478         if (!old_data)
479                 new_job = True;
480
481         /* Job attributes that can't be changed.  We only send
482            notification for these on a new job. */
483
484         /* ACHTUNG!  Due to a bug in Samba's spoolss parsing of the 
485            NOTIFY_INFO_DATA buffer, we *have* to send the job submission 
486            time first or else we'll end up with potential alignment 
487            errors.  I don't think the systemtime should be spooled as 
488            a string, but this gets us around that error.   
489            --jerry (i'll feel dirty for this) */
490  
491         if (new_job) {
492                 notify_job_submitted(sharename, jobid, new_data->starttime);
493                 notify_job_username(sharename, jobid, new_data->user);
494         }
495
496         if (new_job || !strequal(old_data->jobname, new_data->jobname))
497                 notify_job_name(sharename, jobid, new_data->jobname);
498
499         /* Job attributes of a new job or attributes that can be
500            modified. */
501
502         if (new_job || !strequal(old_data->jobname, new_data->jobname))
503                 notify_job_name(sharename, jobid, new_data->jobname);
504
505         if (new_job || old_data->status != new_data->status)
506                 notify_job_status(sharename, jobid, map_to_spoolss_status(new_data->status));
507
508         if (new_job || old_data->size != new_data->size)
509                 notify_job_total_bytes(sharename, jobid, new_data->size);
510
511         if (new_job || old_data->page_count != new_data->page_count)
512                 notify_job_total_pages(sharename, jobid, new_data->page_count);
513 }
514
515 /****************************************************************************
516  Store a job structure back to the database.
517 ****************************************************************************/
518
519 static bool pjob_store(const char* sharename, uint32 jobid, struct printjob *pjob)
520 {
521         uint32_t tmp;
522         TDB_DATA                old_data, new_data;
523         bool                    ret = False;
524         struct tdb_print_db     *pdb = get_print_db_byname(sharename);
525         uint8                   *buf = NULL;
526         int                     len, newlen, buflen;
527         
528
529         if (!pdb)
530                 return False;
531
532         /* Get old data */
533
534         old_data = tdb_fetch(pdb->tdb, print_key(jobid, &tmp));
535
536         /* Doh!  Now we have to pack/unpack data since the NT_DEVICEMODE was added */
537
538         newlen = 0;
539         
540         do {
541                 len = 0;
542                 buflen = newlen;
543                 len += tdb_pack(buf+len, buflen-len, "dddddddddffff",
544                                 (uint32)pjob->pid,
545                                 (uint32)pjob->sysjob,
546                                 (uint32)pjob->fd,
547                                 (uint32)pjob->starttime,
548                                 (uint32)pjob->status,
549                                 (uint32)pjob->size,
550                                 (uint32)pjob->page_count,
551                                 (uint32)pjob->spooled,
552                                 (uint32)pjob->smbjob,
553                                 pjob->filename,
554                                 pjob->jobname,
555                                 pjob->user,
556                                 pjob->queuename);
557
558                 len += pack_devicemode(pjob->nt_devmode, buf+len, buflen-len);
559         
560                 if (buflen != len) {
561                         buf = (uint8 *)SMB_REALLOC(buf, len);
562                         if (!buf) {
563                                 DEBUG(0,("pjob_store: failed to enlarge buffer!\n"));
564                                 goto done;
565                         }
566                         newlen = len;
567                 }
568         } while ( buflen != len );
569                 
570         
571         /* Store new data */
572
573         new_data.dptr = buf;
574         new_data.dsize = len;
575         ret = (tdb_store(pdb->tdb, print_key(jobid, &tmp), new_data,
576                          TDB_REPLACE) == 0);
577
578         release_print_db(pdb);
579
580         /* Send notify updates for what has changed */
581
582         if ( ret ) {
583                 struct printjob old_pjob;
584
585                 if ( old_data.dsize )
586                 {
587                         if ( unpack_pjob( old_data.dptr, old_data.dsize, &old_pjob ) != -1 )
588                         {
589                                 pjob_store_notify( sharename, jobid, &old_pjob , pjob );
590                                 free_nt_devicemode( &old_pjob.nt_devmode );
591                         }
592                 }
593                 else {
594                         /* new job */
595                         pjob_store_notify( sharename, jobid, NULL, pjob );
596                 }
597         }
598
599 done:
600         SAFE_FREE( old_data.dptr );
601         SAFE_FREE( buf );
602
603         return ret;
604 }
605
606 /****************************************************************************
607  Remove a job structure from the database.
608 ****************************************************************************/
609
610 void pjob_delete(const char* sharename, uint32 jobid)
611 {
612         uint32_t tmp;
613         struct printjob *pjob;
614         uint32 job_status = 0;
615         struct tdb_print_db *pdb;
616
617         pdb = get_print_db_byname( sharename );
618
619         if (!pdb)
620                 return;
621
622         pjob = print_job_find( sharename, jobid );
623
624         if (!pjob) {
625                 DEBUG(5, ("pjob_delete: we were asked to delete nonexistent job %u\n",
626                                         (unsigned int)jobid));
627                 release_print_db(pdb);
628                 return;
629         }
630
631         /* We must cycle through JOB_STATUS_DELETING and
632            JOB_STATUS_DELETED for the port monitor to delete the job
633            properly. */
634         
635         job_status = JOB_STATUS_DELETING|JOB_STATUS_DELETED;
636         notify_job_status(sharename, jobid, job_status);
637         
638         /* Remove from printing.tdb */
639
640         tdb_delete(pdb->tdb, print_key(jobid, &tmp));
641         remove_from_jobs_changed(sharename, jobid);
642         release_print_db( pdb );
643         rap_jobid_delete(sharename, jobid);
644 }
645
646 /****************************************************************************
647  Parse a file name from the system spooler to generate a jobid.
648 ****************************************************************************/
649
650 static uint32 print_parse_jobid(char *fname)
651 {
652         int jobid;
653
654         if (strncmp(fname,PRINT_SPOOL_PREFIX,strlen(PRINT_SPOOL_PREFIX)) != 0)
655                 return (uint32)-1;
656         fname += strlen(PRINT_SPOOL_PREFIX);
657
658         jobid = atoi(fname);
659         if (jobid <= 0)
660                 return (uint32)-1;
661
662         return (uint32)jobid;
663 }
664
665 /****************************************************************************
666  List a unix job in the print database.
667 ****************************************************************************/
668
669 static void print_unix_job(const char *sharename, print_queue_struct *q, uint32 jobid)
670 {
671         struct printjob pj, *old_pj;
672
673         if (jobid == (uint32)-1) 
674                 jobid = q->job + UNIX_JOB_START;
675
676         /* Preserve the timestamp on an existing unix print job */
677
678         old_pj = print_job_find(sharename, jobid);
679
680         ZERO_STRUCT(pj);
681
682         pj.pid = (pid_t)-1;
683         pj.sysjob = q->job;
684         pj.fd = -1;
685         pj.starttime = old_pj ? old_pj->starttime : q->time;
686         pj.status = q->status;
687         pj.size = q->size;
688         pj.spooled = True;
689         fstrcpy(pj.filename, old_pj ? old_pj->filename : "");
690         if (jobid < UNIX_JOB_START) {
691                 pj.smbjob = True;
692                 fstrcpy(pj.jobname, old_pj ? old_pj->jobname : "Remote Downlevel Document");
693         } else {
694                 pj.smbjob = False;
695                 fstrcpy(pj.jobname, old_pj ? old_pj->jobname : q->fs_file);
696         }
697         fstrcpy(pj.user, old_pj ? old_pj->user : q->fs_user);
698         fstrcpy(pj.queuename, old_pj ? old_pj->queuename : sharename );
699
700         pjob_store(sharename, jobid, &pj);
701 }
702
703
704 struct traverse_struct {
705         print_queue_struct *queue;
706         int qcount, snum, maxcount, total_jobs;
707         const char *sharename;
708         time_t lpq_time;
709         const char *lprm_command;
710         struct printif *print_if;
711 };
712
713 /****************************************************************************
714  Utility fn to delete any jobs that are no longer active.
715 ****************************************************************************/
716
717 static int traverse_fn_delete(TDB_CONTEXT *t, TDB_DATA key, TDB_DATA data, void *state)
718 {
719         struct traverse_struct *ts = (struct traverse_struct *)state;
720         struct printjob pjob;
721         uint32 jobid;
722         int i = 0;
723
724         if (  key.dsize != sizeof(jobid) )
725                 return 0;
726                 
727         jobid = IVAL(key.dptr, 0);
728         if ( unpack_pjob( data.dptr, data.dsize, &pjob ) == -1 )
729                 return 0;
730         free_nt_devicemode( &pjob.nt_devmode );
731
732
733         if (!pjob.smbjob) {
734                 /* remove a unix job if it isn't in the system queue any more */
735
736                 for (i=0;i<ts->qcount;i++) {
737                         uint32 u_jobid = (ts->queue[i].job + UNIX_JOB_START);
738                         if (jobid == u_jobid)
739                                 break;
740                 }
741                 if (i == ts->qcount) {
742                         DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !smbjob\n",
743                                                 (unsigned int)jobid ));
744                         pjob_delete(ts->sharename, jobid);
745                         return 0;
746                 } 
747
748                 /* need to continue the the bottom of the function to
749                    save the correct attributes */
750         }
751
752         /* maybe it hasn't been spooled yet */
753         if (!pjob.spooled) {
754                 /* if a job is not spooled and the process doesn't
755                    exist then kill it. This cleans up after smbd
756                    deaths */
757                 if (!process_exists_by_pid(pjob.pid)) {
758                         DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !process_exists (%u)\n",
759                                                 (unsigned int)jobid, (unsigned int)pjob.pid ));
760                         pjob_delete(ts->sharename, jobid);
761                 } else
762                         ts->total_jobs++;
763                 return 0;
764         }
765
766         /* this check only makes sense for jobs submitted from Windows clients */
767         
768         if ( pjob.smbjob ) {
769                 for (i=0;i<ts->qcount;i++) {
770                         uint32 curr_jobid;
771
772                         if ( pjob.status == LPQ_DELETED )
773                                 continue;
774
775                         curr_jobid = print_parse_jobid(ts->queue[i].fs_file);
776
777                         if (jobid == curr_jobid) {
778
779                                 /* try to clean up any jobs that need to be deleted */
780
781                                 if ( pjob.status == LPQ_DELETING ) {
782                                         int result;
783
784                                         result = (*(ts->print_if->job_delete))( 
785                                                 ts->sharename, ts->lprm_command, &pjob );
786
787                                         if ( result != 0 ) {
788                                                 /* if we can't delete, then reset the job status */
789                                                 pjob.status = LPQ_QUEUED;
790                                                 pjob_store(ts->sharename, jobid, &pjob);
791                                         }
792                                         else {
793                                                 /* if we deleted the job, the remove the tdb record */
794                                                 pjob_delete(ts->sharename, jobid);
795                                                 pjob.status = LPQ_DELETED;
796                                         }
797                                                 
798                                 }
799
800                                 break;
801                         }
802                 }
803         }
804         
805         /* The job isn't in the system queue - we have to assume it has
806            completed, so delete the database entry. */
807
808         if (i == ts->qcount) {
809
810                 /* A race can occur between the time a job is spooled and
811                    when it appears in the lpq output.  This happens when
812                    the job is added to printing.tdb when another smbd
813                    running print_queue_update() has completed a lpq and
814                    is currently traversing the printing tdb and deleting jobs.
815                    Don't delete the job if it was submitted after the lpq_time. */
816
817                 if (pjob.starttime < ts->lpq_time) {
818                         DEBUG(10,("traverse_fn_delete: pjob %u deleted due to pjob.starttime (%u) < ts->lpq_time (%u)\n",
819                                                 (unsigned int)jobid,
820                                                 (unsigned int)pjob.starttime,
821                                                 (unsigned int)ts->lpq_time ));
822                         pjob_delete(ts->sharename, jobid);
823                 } else
824                         ts->total_jobs++;
825                 return 0;
826         }
827
828         /* Save the pjob attributes we will store. 
829            FIXME!!! This is the only place where queue->job 
830            represents the SMB jobid      --jerry */
831
832         ts->queue[i].job = jobid;               
833         ts->queue[i].size = pjob.size;
834         ts->queue[i].page_count = pjob.page_count;
835         ts->queue[i].status = pjob.status;
836         ts->queue[i].priority = 1;
837         ts->queue[i].time = pjob.starttime;
838         fstrcpy(ts->queue[i].fs_user, pjob.user);
839         fstrcpy(ts->queue[i].fs_file, pjob.jobname);
840
841         ts->total_jobs++;
842
843         return 0;
844 }
845
846 /****************************************************************************
847  Check if the print queue has been updated recently enough.
848 ****************************************************************************/
849
850 static void print_cache_flush(const char *sharename)
851 {
852         fstring key;
853         struct tdb_print_db *pdb = get_print_db_byname(sharename);
854
855         if (!pdb)
856                 return;
857         slprintf(key, sizeof(key)-1, "CACHE/%s", sharename);
858         tdb_store_int32(pdb->tdb, key, -1);
859         release_print_db(pdb);
860 }
861
862 /****************************************************************************
863  Check if someone already thinks they are doing the update.
864 ****************************************************************************/
865
866 static pid_t get_updating_pid(const char *sharename)
867 {
868         fstring keystr;
869         TDB_DATA data, key;
870         pid_t updating_pid;
871         struct tdb_print_db *pdb = get_print_db_byname(sharename);
872
873         if (!pdb)
874                 return (pid_t)-1;
875         slprintf(keystr, sizeof(keystr)-1, "UPDATING/%s", sharename);
876         key = string_tdb_data(keystr);
877
878         data = tdb_fetch(pdb->tdb, key);
879         release_print_db(pdb);
880         if (!data.dptr || data.dsize != sizeof(pid_t)) {
881                 SAFE_FREE(data.dptr);
882                 return (pid_t)-1;
883         }
884
885         updating_pid = IVAL(data.dptr, 0);
886         SAFE_FREE(data.dptr);
887
888         if (process_exists_by_pid(updating_pid))
889                 return updating_pid;
890
891         return (pid_t)-1;
892 }
893
894 /****************************************************************************
895  Set the fact that we're doing the update, or have finished doing the update
896  in the tdb.
897 ****************************************************************************/
898
899 static void set_updating_pid(const fstring sharename, bool updating)
900 {
901         fstring keystr;
902         TDB_DATA key;
903         TDB_DATA data;
904         pid_t updating_pid = sys_getpid();
905         uint8 buffer[4];
906         
907         struct tdb_print_db *pdb = get_print_db_byname(sharename);
908
909         if (!pdb)
910                 return;
911
912         slprintf(keystr, sizeof(keystr)-1, "UPDATING/%s", sharename);
913         key = string_tdb_data(keystr);
914         
915         DEBUG(5, ("set_updating_pid: %s updating lpq cache for print share %s\n", 
916                 updating ? "" : "not ",
917                 sharename ));
918
919         if ( !updating ) {
920                 tdb_delete(pdb->tdb, key);
921                 release_print_db(pdb);
922                 return;
923         }
924         
925         SIVAL( buffer, 0, updating_pid);
926         data.dptr = buffer;
927         data.dsize = 4;         /* we always assume this is a 4 byte value */
928
929         tdb_store(pdb->tdb, key, data, TDB_REPLACE);    
930         release_print_db(pdb);
931 }
932
933 /****************************************************************************
934  Sort print jobs by submittal time.
935 ****************************************************************************/
936
937 static int printjob_comp(print_queue_struct *j1, print_queue_struct *j2)
938 {
939         /* Silly cases */
940
941         if (!j1 && !j2)
942                 return 0;
943         if (!j1)
944                 return -1;
945         if (!j2)
946                 return 1;
947
948         /* Sort on job start time */
949
950         if (j1->time == j2->time)
951                 return 0;
952         return (j1->time > j2->time) ? 1 : -1;
953 }
954
955 /****************************************************************************
956  Store the sorted queue representation for later portmon retrieval.
957  Skip deleted jobs
958 ****************************************************************************/
959
960 static void store_queue_struct(struct tdb_print_db *pdb, struct traverse_struct *pts)
961 {
962         TDB_DATA data;
963         int max_reported_jobs = lp_max_reported_jobs(pts->snum);
964         print_queue_struct *queue = pts->queue;
965         size_t len;
966         size_t i;
967         unsigned int qcount;
968
969         if (max_reported_jobs && (max_reported_jobs < pts->qcount))
970                 pts->qcount = max_reported_jobs;
971         qcount = 0;
972
973         /* Work out the size. */
974         data.dsize = 0;
975         data.dsize += tdb_pack(NULL, 0, "d", qcount);
976
977         for (i = 0; i < pts->qcount; i++) {
978                 if ( queue[i].status == LPQ_DELETED )
979                         continue;
980
981                 qcount++;
982                 data.dsize += tdb_pack(NULL, 0, "ddddddff",
983                                 (uint32)queue[i].job,
984                                 (uint32)queue[i].size,
985                                 (uint32)queue[i].page_count,
986                                 (uint32)queue[i].status,
987                                 (uint32)queue[i].priority,
988                                 (uint32)queue[i].time,
989                                 queue[i].fs_user,
990                                 queue[i].fs_file);
991         }
992
993         if ((data.dptr = (uint8 *)SMB_MALLOC(data.dsize)) == NULL)
994                 return;
995
996         len = 0;
997         len += tdb_pack(data.dptr + len, data.dsize - len, "d", qcount);
998         for (i = 0; i < pts->qcount; i++) {
999                 if ( queue[i].status == LPQ_DELETED )
1000                         continue;
1001
1002                 len += tdb_pack(data.dptr + len, data.dsize - len, "ddddddff",
1003                                 (uint32)queue[i].job,
1004                                 (uint32)queue[i].size,
1005                                 (uint32)queue[i].page_count,
1006                                 (uint32)queue[i].status,
1007                                 (uint32)queue[i].priority,
1008                                 (uint32)queue[i].time,
1009                                 queue[i].fs_user,
1010                                 queue[i].fs_file);
1011         }
1012
1013         tdb_store(pdb->tdb, string_tdb_data("INFO/linear_queue_array"), data,
1014                   TDB_REPLACE);
1015         SAFE_FREE(data.dptr);
1016         return;
1017 }
1018
1019 static TDB_DATA get_jobs_changed_data(struct tdb_print_db *pdb)
1020 {
1021         TDB_DATA data;
1022
1023         ZERO_STRUCT(data);
1024
1025         data = tdb_fetch(pdb->tdb, string_tdb_data("INFO/jobs_changed"));
1026         if (data.dptr == NULL || data.dsize == 0 || (data.dsize % 4 != 0)) {
1027                 SAFE_FREE(data.dptr);
1028                 ZERO_STRUCT(data);
1029         }
1030
1031         return data;
1032 }
1033
1034 static void check_job_changed(const char *sharename, TDB_DATA data, uint32 jobid)
1035 {
1036         unsigned int i;
1037         unsigned int job_count = data.dsize / 4;
1038
1039         for (i = 0; i < job_count; i++) {
1040                 uint32 ch_jobid;
1041
1042                 ch_jobid = IVAL(data.dptr, i*4);
1043                 if (ch_jobid == jobid)
1044                         remove_from_jobs_changed(sharename, jobid);
1045         }
1046 }
1047
1048 /****************************************************************************
1049  Check if the print queue has been updated recently enough.
1050 ****************************************************************************/
1051
1052 static bool print_cache_expired(const char *sharename, bool check_pending)
1053 {
1054         fstring key;
1055         time_t last_qscan_time, time_now = time(NULL);
1056         struct tdb_print_db *pdb = get_print_db_byname(sharename);
1057         bool result = False;
1058
1059         if (!pdb)
1060                 return False;
1061
1062         snprintf(key, sizeof(key), "CACHE/%s", sharename);
1063         last_qscan_time = (time_t)tdb_fetch_int32(pdb->tdb, key);
1064
1065         /*
1066          * Invalidate the queue for 3 reasons.
1067          * (1). last queue scan time == -1.
1068          * (2). Current time - last queue scan time > allowed cache time.
1069          * (3). last queue scan time > current time + MAX_CACHE_VALID_TIME (1 hour by default).
1070          * This last test picks up machines for which the clock has been moved
1071          * forward, an lpq scan done and then the clock moved back. Otherwise
1072          * that last lpq scan would stay around for a loooong loooong time... :-). JRA.
1073          */
1074
1075         if (last_qscan_time == ((time_t)-1) 
1076                 || (time_now - last_qscan_time) >= lp_lpqcachetime() 
1077                 || last_qscan_time > (time_now + MAX_CACHE_VALID_TIME)) 
1078         {
1079                 uint32 u;
1080                 time_t msg_pending_time;
1081
1082                 DEBUG(4, ("print_cache_expired: cache expired for queue %s " 
1083                         "(last_qscan_time = %d, time now = %d, qcachetime = %d)\n", 
1084                         sharename, (int)last_qscan_time, (int)time_now, 
1085                         (int)lp_lpqcachetime() ));
1086
1087                 /* check if another smbd has already sent a message to update the 
1088                    queue.  Give the pending message one minute to clear and 
1089                    then send another message anyways.  Make sure to check for 
1090                    clocks that have been run forward and then back again. */
1091
1092                 snprintf(key, sizeof(key), "MSG_PENDING/%s", sharename);
1093
1094                 if ( check_pending 
1095                         && tdb_fetch_uint32( pdb->tdb, key, &u ) 
1096                         && (msg_pending_time=u) > 0
1097                         && msg_pending_time <= time_now 
1098                         && (time_now - msg_pending_time) < 60 ) 
1099                 {
1100                         DEBUG(4,("print_cache_expired: message already pending for %s.  Accepting cache\n",
1101                                 sharename));
1102                         goto done;
1103                 }
1104                 
1105                 result = True;
1106         }
1107
1108 done:
1109         release_print_db(pdb);
1110         return result;
1111 }
1112
1113 /****************************************************************************
1114  main work for updating the lpq cahe for a printer queue
1115 ****************************************************************************/
1116
1117 static void print_queue_update_internal( const char *sharename, 
1118                                          struct printif *current_printif,
1119                                          char *lpq_command, char *lprm_command )
1120 {
1121         int i, qcount;
1122         print_queue_struct *queue = NULL;
1123         print_status_struct status;
1124         print_status_struct old_status;
1125         struct printjob *pjob;
1126         struct traverse_struct tstruct;
1127         TDB_DATA data, key;
1128         TDB_DATA jcdata;
1129         fstring keystr, cachestr;
1130         struct tdb_print_db *pdb = get_print_db_byname(sharename);
1131
1132         if (!pdb) {
1133                 return;
1134         }
1135         
1136         DEBUG(5,("print_queue_update_internal: printer = %s, type = %d, lpq command = [%s]\n",
1137                 sharename, current_printif->type, lpq_command));
1138
1139         /*
1140          * Update the cache time FIRST ! Stops others even
1141          * attempting to get the lock and doing this
1142          * if the lpq takes a long time.
1143          */
1144          
1145         slprintf(cachestr, sizeof(cachestr)-1, "CACHE/%s", sharename);
1146         tdb_store_int32(pdb->tdb, cachestr, (int)time(NULL));
1147
1148         /* get the current queue using the appropriate interface */
1149         ZERO_STRUCT(status);
1150
1151         qcount = (*(current_printif->queue_get))(sharename, 
1152                 current_printif->type, 
1153                 lpq_command, &queue, &status);
1154
1155         DEBUG(3, ("print_queue_update_internal: %d job%s in queue for %s\n", 
1156                 qcount, (qcount != 1) ? "s" : "", sharename));
1157
1158         /* Sort the queue by submission time otherwise they are displayed
1159            in hash order. */
1160
1161         qsort(queue, qcount, sizeof(print_queue_struct),
1162                 QSORT_CAST(printjob_comp));
1163
1164         /*
1165           any job in the internal database that is marked as spooled
1166           and doesn't exist in the system queue is considered finished
1167           and removed from the database
1168
1169           any job in the system database but not in the internal database 
1170           is added as a unix job
1171
1172           fill in any system job numbers as we go
1173         */
1174
1175         jcdata = get_jobs_changed_data(pdb);
1176
1177         for (i=0; i<qcount; i++) {
1178                 uint32 jobid = print_parse_jobid(queue[i].fs_file);
1179
1180                 if (jobid == (uint32)-1) {
1181                         /* assume its a unix print job */
1182                         print_unix_job(sharename, &queue[i], jobid);
1183                         continue;
1184                 }
1185
1186                 /* we have an active SMB print job - update its status */
1187                 pjob = print_job_find(sharename, jobid);
1188                 if (!pjob) {
1189                         /* err, somethings wrong. Probably smbd was restarted
1190                            with jobs in the queue. All we can do is treat them
1191                            like unix jobs. Pity. */
1192                         print_unix_job(sharename, &queue[i], jobid);
1193                         continue;
1194                 }
1195
1196                 pjob->sysjob = queue[i].job;
1197
1198                 /* don't reset the status on jobs to be deleted */
1199
1200                 if ( pjob->status != LPQ_DELETING )
1201                         pjob->status = queue[i].status;
1202
1203                 pjob_store(sharename, jobid, pjob);
1204
1205                 check_job_changed(sharename, jcdata, jobid);
1206         }
1207
1208         SAFE_FREE(jcdata.dptr);
1209
1210         /* now delete any queued entries that don't appear in the
1211            system queue */
1212         tstruct.queue = queue;
1213         tstruct.qcount = qcount;
1214         tstruct.snum = -1;
1215         tstruct.total_jobs = 0;
1216         tstruct.lpq_time = time(NULL);
1217         tstruct.sharename = sharename;
1218         tstruct.lprm_command = lprm_command;
1219         tstruct.print_if = current_printif;
1220
1221         tdb_traverse(pdb->tdb, traverse_fn_delete, (void *)&tstruct);
1222
1223         /* Store the linearised queue, max jobs only. */
1224         store_queue_struct(pdb, &tstruct);
1225
1226         SAFE_FREE(tstruct.queue);
1227
1228         DEBUG(10,("print_queue_update_internal: printer %s INFO/total_jobs = %d\n",
1229                                 sharename, tstruct.total_jobs ));
1230
1231         tdb_store_int32(pdb->tdb, "INFO/total_jobs", tstruct.total_jobs);
1232
1233         get_queue_status(sharename, &old_status);
1234         if (old_status.qcount != qcount)
1235                 DEBUG(10,("print_queue_update_internal: queue status change %d jobs -> %d jobs for printer %s\n",
1236                                         old_status.qcount, qcount, sharename));
1237
1238         /* store the new queue status structure */
1239         slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", sharename);
1240         key = string_tdb_data(keystr);
1241
1242         status.qcount = qcount;
1243         data.dptr = (uint8 *)&status;
1244         data.dsize = sizeof(status);
1245         tdb_store(pdb->tdb, key, data, TDB_REPLACE);    
1246
1247         /*
1248          * Update the cache time again. We want to do this call
1249          * as little as possible...
1250          */
1251
1252         slprintf(keystr, sizeof(keystr)-1, "CACHE/%s", sharename);
1253         tdb_store_int32(pdb->tdb, keystr, (int32)time(NULL));
1254
1255         /* clear the msg pending record for this queue */
1256
1257         snprintf(keystr, sizeof(keystr), "MSG_PENDING/%s", sharename);
1258
1259         if ( !tdb_store_uint32( pdb->tdb, keystr, 0 ) ) {
1260                 /* log a message but continue on */
1261
1262                 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1263                         sharename));
1264         }
1265
1266         release_print_db( pdb );
1267
1268         return;
1269 }
1270
1271 /****************************************************************************
1272  Update the internal database from the system print queue for a queue.
1273  obtain a lock on the print queue before proceeding (needed when mutiple
1274  smbd processes maytry to update the lpq cache concurrently).
1275 ****************************************************************************/
1276
1277 static void print_queue_update_with_lock( const char *sharename, 
1278                                           struct printif *current_printif,
1279                                           char *lpq_command, char *lprm_command )
1280 {
1281         fstring keystr;
1282         struct tdb_print_db *pdb;
1283
1284         DEBUG(5,("print_queue_update_with_lock: printer share = %s\n", sharename));
1285         pdb = get_print_db_byname(sharename);
1286         if (!pdb)
1287                 return;
1288
1289         if ( !print_cache_expired(sharename, False) ) {
1290                 DEBUG(5,("print_queue_update_with_lock: print cache for %s is still ok\n", sharename));
1291                 release_print_db(pdb);
1292                 return;
1293         }
1294         
1295         /*
1296          * Check to see if someone else is doing this update.
1297          * This is essentially a mutex on the update.
1298          */
1299
1300         if (get_updating_pid(sharename) != -1) {
1301                 release_print_db(pdb);
1302                 return;
1303         }
1304
1305         /* Lock the queue for the database update */
1306
1307         slprintf(keystr, sizeof(keystr) - 1, "LOCK/%s", sharename);
1308         /* Only wait 10 seconds for this. */
1309         if (tdb_lock_bystring_with_timeout(pdb->tdb, keystr, 10) == -1) {
1310                 DEBUG(0,("print_queue_update_with_lock: Failed to lock printer %s database\n", sharename));
1311                 release_print_db(pdb);
1312                 return;
1313         }
1314
1315         /*
1316          * Ensure that no one else got in here.
1317          * If the updating pid is still -1 then we are
1318          * the winner.
1319          */
1320
1321         if (get_updating_pid(sharename) != -1) {
1322                 /*
1323                  * Someone else is doing the update, exit.
1324                  */
1325                 tdb_unlock_bystring(pdb->tdb, keystr);
1326                 release_print_db(pdb);
1327                 return;
1328         }
1329
1330         /*
1331          * We're going to do the update ourselves.
1332          */
1333
1334         /* Tell others we're doing the update. */
1335         set_updating_pid(sharename, True);
1336
1337         /*
1338          * Allow others to enter and notice we're doing
1339          * the update.
1340          */
1341
1342         tdb_unlock_bystring(pdb->tdb, keystr);
1343
1344         /* do the main work now */
1345         
1346         print_queue_update_internal( sharename, current_printif, 
1347                 lpq_command, lprm_command );
1348         
1349         /* Delete our pid from the db. */
1350         set_updating_pid(sharename, False);
1351         release_print_db(pdb);
1352 }
1353
1354 /****************************************************************************
1355 this is the receive function of the background lpq updater
1356 ****************************************************************************/
1357 static void print_queue_receive(struct messaging_context *msg,
1358                                 void *private_data,
1359                                 uint32_t msg_type,
1360                                 struct server_id server_id,
1361                                 DATA_BLOB *data)
1362 {
1363         fstring sharename;
1364         char *lpqcommand = NULL, *lprmcommand = NULL;
1365         int printing_type;
1366         size_t len;
1367
1368         len = tdb_unpack( (uint8 *)data->data, data->length, "fdPP",
1369                 sharename,
1370                 &printing_type,
1371                 &lpqcommand,
1372                 &lprmcommand );
1373
1374         if ( len == -1 ) {
1375                 SAFE_FREE(lpqcommand);
1376                 SAFE_FREE(lprmcommand);
1377                 DEBUG(0,("print_queue_receive: Got invalid print queue update message\n"));
1378                 return;
1379         }
1380
1381         print_queue_update_with_lock(sharename, 
1382                 get_printer_fns_from_type((enum printing_types)printing_type),
1383                 lpqcommand, lprmcommand );
1384
1385         SAFE_FREE(lpqcommand);
1386         SAFE_FREE(lprmcommand);
1387         return;
1388 }
1389
1390 static pid_t background_lpq_updater_pid = -1;
1391
1392 /****************************************************************************
1393 main thread of the background lpq updater
1394 ****************************************************************************/
1395 void start_background_queue(void)
1396 {
1397         DEBUG(3,("start_background_queue: Starting background LPQ thread\n"));
1398         background_lpq_updater_pid = sys_fork();
1399
1400         if (background_lpq_updater_pid == -1) {
1401                 DEBUG(5,("start_background_queue: background LPQ thread failed to start. %s\n", strerror(errno) ));
1402                 exit(1);
1403         }
1404
1405         if(background_lpq_updater_pid == 0) {
1406                 /* Child. */
1407                 DEBUG(5,("start_background_queue: background LPQ thread started\n"));
1408
1409                 if (!reinit_after_fork(smbd_messaging_context(), true)) {
1410                         DEBUG(0,("reinit_after_fork() failed\n"));
1411                         smb_panic("reinit_after_fork() failed");
1412                 }
1413
1414                 claim_connection( NULL, "smbd lpq backend",
1415                         FLAG_MSG_GENERAL|FLAG_MSG_SMBD|FLAG_MSG_PRINT_GENERAL);
1416
1417                 if (!locking_init()) {
1418                         exit(1);
1419                 }
1420
1421                 messaging_register(smbd_messaging_context(), NULL,
1422                                    MSG_PRINTER_UPDATE, print_queue_receive);
1423                 
1424                 DEBUG(5,("start_background_queue: background LPQ thread waiting for messages\n"));
1425                 while (1) {
1426                         pause();
1427                         
1428                         /* check for some essential signals first */
1429                         
1430                         if (got_sig_term) {
1431                                 exit_server_cleanly(NULL);
1432                         }
1433
1434                         if (reload_after_sighup) {
1435                                 change_to_root_user();
1436                                 DEBUG(1,("Reloading services after SIGHUP\n"));
1437                                 reload_services(False);
1438                                 reload_after_sighup = 0;
1439                         }
1440                         
1441                         /* now check for messages */
1442                         
1443                         DEBUG(10,("start_background_queue: background LPQ thread got a message\n"));
1444                         message_dispatch(smbd_messaging_context());
1445
1446                         /* process any pending print change notify messages */
1447
1448                         print_notify_send_messages(smbd_messaging_context(),
1449                                                    0);
1450                 }
1451         }
1452 }
1453
1454 /****************************************************************************
1455 update the internal database from the system print queue for a queue
1456 ****************************************************************************/
1457
1458 static void print_queue_update(int snum, bool force)
1459 {
1460         fstring key;
1461         fstring sharename;
1462         char *lpqcommand = NULL;
1463         char *lprmcommand = NULL;
1464         uint8 *buffer = NULL;
1465         size_t len = 0;
1466         size_t newlen;
1467         struct tdb_print_db *pdb;
1468         int type;
1469         struct printif *current_printif;
1470         TALLOC_CTX *ctx = talloc_tos();
1471
1472         fstrcpy( sharename, lp_const_servicename(snum));
1473
1474         /* don't strip out characters like '$' from the printername */
1475
1476         lpqcommand = talloc_string_sub2(ctx,
1477                         lp_lpqcommand(snum),
1478                         "%p",
1479                         PRINTERNAME(snum),
1480                         false, false, false);
1481         if (!lpqcommand) {
1482                 return;
1483         }
1484         lpqcommand = talloc_sub_advanced(ctx,
1485                         lp_servicename(snum),
1486                         current_user_info.unix_name,
1487                         "",
1488                         current_user.ut.gid,
1489                         get_current_username(),
1490                         current_user_info.domain,
1491                         lpqcommand);
1492         if (!lpqcommand) {
1493                 return;
1494         }
1495
1496         lprmcommand = talloc_string_sub2(ctx,
1497                         lp_lprmcommand(snum),
1498                         "%p",
1499                         PRINTERNAME(snum),
1500                         false, false, false);
1501         if (!lprmcommand) {
1502                 return;
1503         }
1504         lprmcommand = talloc_sub_advanced(ctx,
1505                         lp_servicename(snum),
1506                         current_user_info.unix_name,
1507                         "",
1508                         current_user.ut.gid,
1509                         get_current_username(),
1510                         current_user_info.domain,
1511                         lprmcommand);
1512         if (!lprmcommand) {
1513                 return;
1514         }
1515
1516         /*
1517          * Make sure that the background queue process exists.
1518          * Otherwise just do the update ourselves
1519          */
1520
1521         if ( force || background_lpq_updater_pid == -1 ) {
1522                 DEBUG(4,("print_queue_update: updating queue [%s] myself\n", sharename));
1523                 current_printif = get_printer_fns( snum );
1524                 print_queue_update_with_lock( sharename, current_printif, lpqcommand, lprmcommand );
1525
1526                 return;
1527         }
1528
1529         type = lp_printing(snum);
1530
1531         /* get the length */
1532
1533         len = tdb_pack( NULL, 0, "fdPP",
1534                 sharename,
1535                 type,
1536                 lpqcommand,
1537                 lprmcommand );
1538
1539         buffer = SMB_XMALLOC_ARRAY( uint8, len );
1540
1541         /* now pack the buffer */
1542         newlen = tdb_pack( buffer, len, "fdPP",
1543                 sharename,
1544                 type,
1545                 lpqcommand,
1546                 lprmcommand );
1547
1548         SMB_ASSERT( newlen == len );
1549
1550         DEBUG(10,("print_queue_update: Sending message -> printer = %s, "
1551                 "type = %d, lpq command = [%s] lprm command = [%s]\n", 
1552                 sharename, type, lpqcommand, lprmcommand ));
1553
1554         /* here we set a msg pending record for other smbd processes 
1555            to throttle the number of duplicate print_queue_update msgs
1556            sent.  */
1557
1558         pdb = get_print_db_byname(sharename);
1559         if (!pdb) {
1560                 SAFE_FREE(buffer);
1561                 return;
1562         }
1563
1564         snprintf(key, sizeof(key), "MSG_PENDING/%s", sharename);
1565
1566         if ( !tdb_store_uint32( pdb->tdb, key, time(NULL) ) ) {
1567                 /* log a message but continue on */
1568
1569                 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1570                         sharename));
1571         }
1572
1573         release_print_db( pdb );
1574
1575         /* finally send the message */
1576         
1577         messaging_send_buf(smbd_messaging_context(),
1578                            pid_to_procid(background_lpq_updater_pid),
1579                            MSG_PRINTER_UPDATE, (uint8 *)buffer, len);
1580
1581         SAFE_FREE( buffer );
1582
1583         return;
1584 }
1585
1586 /****************************************************************************
1587  Create/Update an entry in the print tdb that will allow us to send notify
1588  updates only to interested smbd's. 
1589 ****************************************************************************/
1590
1591 bool print_notify_register_pid(int snum)
1592 {
1593         TDB_DATA data;
1594         struct tdb_print_db *pdb = NULL;
1595         TDB_CONTEXT *tdb = NULL;
1596         const char *printername;
1597         uint32 mypid = (uint32)sys_getpid();
1598         bool ret = False;
1599         size_t i;
1600
1601         /* if (snum == -1), then the change notify request was
1602            on a print server handle and we need to register on
1603            all print queus */
1604            
1605         if (snum == -1) 
1606         {
1607                 int num_services = lp_numservices();
1608                 int idx;
1609                 
1610                 for ( idx=0; idx<num_services; idx++ ) {
1611                         if (lp_snum_ok(idx) && lp_print_ok(idx) )
1612                                 print_notify_register_pid(idx);
1613                 }
1614                 
1615                 return True;
1616         }
1617         else /* register for a specific printer */
1618         {
1619                 printername = lp_const_servicename(snum);
1620                 pdb = get_print_db_byname(printername);
1621                 if (!pdb)
1622                         return False;
1623                 tdb = pdb->tdb;
1624         }
1625
1626         if (tdb_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) == -1) {
1627                 DEBUG(0,("print_notify_register_pid: Failed to lock printer %s\n",
1628                                         printername));
1629                 if (pdb)
1630                         release_print_db(pdb);
1631                 return False;
1632         }
1633
1634         data = get_printer_notify_pid_list( tdb, printername, True );
1635
1636         /* Add ourselves and increase the refcount. */
1637
1638         for (i = 0; i < data.dsize; i += 8) {
1639                 if (IVAL(data.dptr,i) == mypid) {
1640                         uint32 new_refcount = IVAL(data.dptr, i+4) + 1;
1641                         SIVAL(data.dptr, i+4, new_refcount);
1642                         break;
1643                 }
1644         }
1645
1646         if (i == data.dsize) {
1647                 /* We weren't in the list. Realloc. */
1648                 data.dptr = (uint8 *)SMB_REALLOC(data.dptr, data.dsize + 8);
1649                 if (!data.dptr) {
1650                         DEBUG(0,("print_notify_register_pid: Relloc fail for printer %s\n",
1651                                                 printername));
1652                         goto done;
1653                 }
1654                 data.dsize += 8;
1655                 SIVAL(data.dptr,data.dsize - 8,mypid);
1656                 SIVAL(data.dptr,data.dsize - 4,1); /* Refcount. */
1657         }
1658
1659         /* Store back the record. */
1660         if (tdb_store_bystring(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) == -1) {
1661                 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1662 list for printer %s\n", printername));
1663                 goto done;
1664         }
1665
1666         ret = True;
1667
1668  done:
1669
1670         tdb_unlock_bystring(tdb, NOTIFY_PID_LIST_KEY);
1671         if (pdb)
1672                 release_print_db(pdb);
1673         SAFE_FREE(data.dptr);
1674         return ret;
1675 }
1676
1677 /****************************************************************************
1678  Update an entry in the print tdb that will allow us to send notify
1679  updates only to interested smbd's. 
1680 ****************************************************************************/
1681
1682 bool print_notify_deregister_pid(int snum)
1683 {
1684         TDB_DATA data;
1685         struct tdb_print_db *pdb = NULL;
1686         TDB_CONTEXT *tdb = NULL;
1687         const char *printername;
1688         uint32 mypid = (uint32)sys_getpid();
1689         size_t i;
1690         bool ret = False;
1691
1692         /* if ( snum == -1 ), we are deregister a print server handle
1693            which means to deregister on all print queues */
1694            
1695         if (snum == -1) 
1696         {
1697                 int num_services = lp_numservices();
1698                 int idx;
1699                 
1700                 for ( idx=0; idx<num_services; idx++ ) {
1701                         if ( lp_snum_ok(idx) && lp_print_ok(idx) )
1702                                 print_notify_deregister_pid(idx);
1703                 }
1704                 
1705                 return True;
1706         }
1707         else /* deregister a specific printer */
1708         {
1709                 printername = lp_const_servicename(snum);
1710                 pdb = get_print_db_byname(printername);
1711                 if (!pdb)
1712                         return False;
1713                 tdb = pdb->tdb;
1714         }
1715
1716         if (tdb_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) == -1) {
1717                 DEBUG(0,("print_notify_register_pid: Failed to lock \
1718 printer %s database\n", printername));
1719                 if (pdb)
1720                         release_print_db(pdb);
1721                 return False;
1722         }
1723
1724         data = get_printer_notify_pid_list( tdb, printername, True );
1725
1726         /* Reduce refcount. Remove ourselves if zero. */
1727
1728         for (i = 0; i < data.dsize; ) {
1729                 if (IVAL(data.dptr,i) == mypid) {
1730                         uint32 refcount = IVAL(data.dptr, i+4);
1731
1732                         refcount--;
1733
1734                         if (refcount == 0) {
1735                                 if (data.dsize - i > 8)
1736                                         memmove( &data.dptr[i], &data.dptr[i+8], data.dsize - i - 8);
1737                                 data.dsize -= 8;
1738                                 continue;
1739                         }
1740                         SIVAL(data.dptr, i+4, refcount);
1741                 }
1742
1743                 i += 8;
1744         }
1745
1746         if (data.dsize == 0)
1747                 SAFE_FREE(data.dptr);
1748
1749         /* Store back the record. */
1750         if (tdb_store_bystring(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) == -1) {
1751                 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1752 list for printer %s\n", printername));
1753                 goto done;
1754         }
1755
1756         ret = True;
1757
1758   done:
1759
1760         tdb_unlock_bystring(tdb, NOTIFY_PID_LIST_KEY);
1761         if (pdb)
1762                 release_print_db(pdb);
1763         SAFE_FREE(data.dptr);
1764         return ret;
1765 }
1766
1767 /****************************************************************************
1768  Check if a jobid is valid. It is valid if it exists in the database.
1769 ****************************************************************************/
1770
1771 bool print_job_exists(const char* sharename, uint32 jobid)
1772 {
1773         struct tdb_print_db *pdb = get_print_db_byname(sharename);
1774         bool ret;
1775         uint32_t tmp;
1776
1777         if (!pdb)
1778                 return False;
1779         ret = tdb_exists(pdb->tdb, print_key(jobid, &tmp));
1780         release_print_db(pdb);
1781         return ret;
1782 }
1783
1784 /****************************************************************************
1785  Give the fd used for a jobid.
1786 ****************************************************************************/
1787
1788 int print_job_fd(const char* sharename, uint32 jobid)
1789 {
1790         struct printjob *pjob = print_job_find(sharename, jobid);
1791         if (!pjob)
1792                 return -1;
1793         /* don't allow another process to get this info - it is meaningless */
1794         if (pjob->pid != sys_getpid())
1795                 return -1;
1796         return pjob->fd;
1797 }
1798
1799 /****************************************************************************
1800  Give the filename used for a jobid.
1801  Only valid for the process doing the spooling and when the job
1802  has not been spooled.
1803 ****************************************************************************/
1804
1805 char *print_job_fname(const char* sharename, uint32 jobid)
1806 {
1807         struct printjob *pjob = print_job_find(sharename, jobid);
1808         if (!pjob || pjob->spooled || pjob->pid != sys_getpid())
1809                 return NULL;
1810         return pjob->filename;
1811 }
1812
1813
1814 /****************************************************************************
1815  Give the filename used for a jobid.
1816  Only valid for the process doing the spooling and when the job
1817  has not been spooled.
1818 ****************************************************************************/
1819
1820 NT_DEVICEMODE *print_job_devmode(const char* sharename, uint32 jobid)
1821 {
1822         struct printjob *pjob = print_job_find(sharename, jobid);
1823         
1824         if ( !pjob )
1825                 return NULL;
1826                 
1827         return pjob->nt_devmode;
1828 }
1829
1830 /****************************************************************************
1831  Set the place in the queue for a job.
1832 ****************************************************************************/
1833
1834 bool print_job_set_place(const char *sharename, uint32 jobid, int place)
1835 {
1836         DEBUG(2,("print_job_set_place not implemented yet\n"));
1837         return False;
1838 }
1839
1840 /****************************************************************************
1841  Set the name of a job. Only possible for owner.
1842 ****************************************************************************/
1843
1844 bool print_job_set_name(const char *sharename, uint32 jobid, char *name)
1845 {
1846         struct printjob *pjob;
1847
1848         pjob = print_job_find(sharename, jobid);
1849         if (!pjob || pjob->pid != sys_getpid())
1850                 return False;
1851
1852         fstrcpy(pjob->jobname, name);
1853         return pjob_store(sharename, jobid, pjob);
1854 }
1855
1856 /***************************************************************************
1857  Remove a jobid from the 'jobs changed' list.
1858 ***************************************************************************/
1859
1860 static bool remove_from_jobs_changed(const char* sharename, uint32 jobid)
1861 {
1862         struct tdb_print_db *pdb = get_print_db_byname(sharename);
1863         TDB_DATA data, key;
1864         size_t job_count, i;
1865         bool ret = False;
1866         bool gotlock = False;
1867
1868         if (!pdb) {
1869                 return False;
1870         }
1871
1872         ZERO_STRUCT(data);
1873
1874         key = string_tdb_data("INFO/jobs_changed");
1875
1876         if (tdb_chainlock_with_timeout(pdb->tdb, key, 5) == -1)
1877                 goto out;
1878
1879         gotlock = True;
1880
1881         data = tdb_fetch(pdb->tdb, key);
1882
1883         if (data.dptr == NULL || data.dsize == 0 || (data.dsize % 4 != 0))
1884                 goto out;
1885
1886         job_count = data.dsize / 4;
1887         for (i = 0; i < job_count; i++) {
1888                 uint32 ch_jobid;
1889
1890                 ch_jobid = IVAL(data.dptr, i*4);
1891                 if (ch_jobid == jobid) {
1892                         if (i < job_count -1 )
1893                                 memmove(data.dptr + (i*4), data.dptr + (i*4) + 4, (job_count - i - 1)*4 );
1894                         data.dsize -= 4;
1895                         if (tdb_store(pdb->tdb, key, data, TDB_REPLACE) == -1)
1896                                 goto out;
1897                         break;
1898                 }
1899         }
1900
1901         ret = True;
1902   out:
1903
1904         if (gotlock)
1905                 tdb_chainunlock(pdb->tdb, key);
1906         SAFE_FREE(data.dptr);
1907         release_print_db(pdb);
1908         if (ret)
1909                 DEBUG(10,("remove_from_jobs_changed: removed jobid %u\n", (unsigned int)jobid ));
1910         else
1911                 DEBUG(10,("remove_from_jobs_changed: Failed to remove jobid %u\n", (unsigned int)jobid ));
1912         return ret;
1913 }
1914
1915 /****************************************************************************
1916  Delete a print job - don't update queue.
1917 ****************************************************************************/
1918
1919 static bool print_job_delete1(int snum, uint32 jobid)
1920 {
1921         const char* sharename = lp_const_servicename(snum);
1922         struct printjob *pjob = print_job_find(sharename, jobid);
1923         int result = 0;
1924         struct printif *current_printif = get_printer_fns( snum );
1925
1926         if (!pjob)
1927                 return False;
1928
1929         /*
1930          * If already deleting just return.
1931          */
1932
1933         if (pjob->status == LPQ_DELETING)
1934                 return True;
1935
1936         /* Hrm - we need to be able to cope with deleting a job before it
1937            has reached the spooler.  Just mark it as LPQ_DELETING and 
1938            let the print_queue_update() code rmeove the record */
1939            
1940
1941         if (pjob->sysjob == -1) {
1942                 DEBUG(5, ("attempt to delete job %u not seen by lpr\n", (unsigned int)jobid));
1943         }
1944
1945         /* Set the tdb entry to be deleting. */
1946
1947         pjob->status = LPQ_DELETING;
1948         pjob_store(sharename, jobid, pjob);
1949
1950         if (pjob->spooled && pjob->sysjob != -1) 
1951         {
1952                 result = (*(current_printif->job_delete))(
1953                         PRINTERNAME(snum),
1954                         lp_lprmcommand(snum), 
1955                         pjob);
1956
1957                 /* Delete the tdb entry if the delete succeeded or the job hasn't
1958                    been spooled. */
1959
1960                 if (result == 0) {
1961                         struct tdb_print_db *pdb = get_print_db_byname(sharename);
1962                         int njobs = 1;
1963
1964                         if (!pdb)
1965                                 return False;
1966                         pjob_delete(sharename, jobid);
1967                         /* Ensure we keep a rough count of the number of total jobs... */
1968                         tdb_change_int32_atomic(pdb->tdb, "INFO/total_jobs", &njobs, -1);
1969                         release_print_db(pdb);
1970                 }
1971         }
1972
1973         remove_from_jobs_changed( sharename, jobid );
1974
1975         return (result == 0);
1976 }
1977
1978 /****************************************************************************
1979  Return true if the current user owns the print job.
1980 ****************************************************************************/
1981
1982 static bool is_owner(struct auth_serversupplied_info *server_info,
1983                      const char *servicename,
1984                      uint32 jobid)
1985 {
1986         struct printjob *pjob = print_job_find(servicename, jobid);
1987
1988         if (!pjob || !server_info)
1989                 return False;
1990
1991         return strequal(pjob->user, server_info->sanitized_username);
1992 }
1993
1994 /****************************************************************************
1995  Delete a print job.
1996 ****************************************************************************/
1997
1998 bool print_job_delete(struct auth_serversupplied_info *server_info, int snum,
1999                       uint32 jobid, WERROR *errcode)
2000 {
2001         const char* sharename = lp_const_servicename( snum );
2002         struct printjob *pjob;
2003         bool    owner;
2004         char    *fname;
2005
2006         *errcode = WERR_OK;
2007                 
2008         owner = is_owner(server_info, lp_const_servicename(snum), jobid);
2009         
2010         /* Check access against security descriptor or whether the user
2011            owns their job. */
2012
2013         if (!owner && 
2014             !print_access_check(server_info, snum, JOB_ACCESS_ADMINISTER)) {
2015                 DEBUG(3, ("delete denied by security descriptor\n"));
2016                 *errcode = WERR_ACCESS_DENIED;
2017
2018                 /* BEGIN_ADMIN_LOG */
2019                 sys_adminlog( LOG_ERR, 
2020                               "Permission denied-- user not allowed to delete, \
2021 pause, or resume print job. User name: %s. Printer name: %s.",
2022                               uidtoname(server_info->utok.uid),
2023                               PRINTERNAME(snum) );
2024                 /* END_ADMIN_LOG */
2025
2026                 return False;
2027         }
2028
2029         /* 
2030          * get the spooled filename of the print job
2031          * if this works, then the file has not been spooled
2032          * to the underlying print system.  Just delete the 
2033          * spool file & return.
2034          */
2035          
2036         if ( (fname = print_job_fname( sharename, jobid )) != NULL )
2037         {
2038                 /* remove the spool file */
2039                 DEBUG(10,("print_job_delete: Removing spool file [%s]\n", fname ));
2040                 if ( unlink( fname ) == -1 ) {
2041                         *errcode = map_werror_from_unix(errno);
2042                         return False;
2043                 }
2044         }
2045         
2046         if (!print_job_delete1(snum, jobid)) {
2047                 *errcode = WERR_ACCESS_DENIED;
2048                 return False;
2049         }
2050
2051         /* force update the database and say the delete failed if the
2052            job still exists */
2053
2054         print_queue_update(snum, True);
2055         
2056         pjob = print_job_find(sharename, jobid);
2057         if ( pjob && (pjob->status != LPQ_DELETING) )
2058                 *errcode = WERR_ACCESS_DENIED;
2059
2060         return (pjob == NULL );
2061 }
2062
2063 /****************************************************************************
2064  Pause a job.
2065 ****************************************************************************/
2066
2067 bool print_job_pause(struct auth_serversupplied_info *server_info, int snum,
2068                      uint32 jobid, WERROR *errcode)
2069 {
2070         const char* sharename = lp_const_servicename(snum);
2071         struct printjob *pjob;
2072         int ret = -1;
2073         struct printif *current_printif = get_printer_fns( snum );
2074
2075         pjob = print_job_find(sharename, jobid);
2076         
2077         if (!pjob || !server_info) {
2078                 DEBUG(10, ("print_job_pause: no pjob or user for jobid %u\n",
2079                         (unsigned int)jobid ));
2080                 return False;
2081         }
2082
2083         if (!pjob->spooled || pjob->sysjob == -1) {
2084                 DEBUG(10, ("print_job_pause: not spooled or bad sysjob = %d for jobid %u\n",
2085                         (int)pjob->sysjob, (unsigned int)jobid ));
2086                 return False;
2087         }
2088
2089         if (!is_owner(server_info, lp_const_servicename(snum), jobid) &&
2090             !print_access_check(server_info, snum, JOB_ACCESS_ADMINISTER)) {
2091                 DEBUG(3, ("pause denied by security descriptor\n"));
2092
2093                 /* BEGIN_ADMIN_LOG */
2094                 sys_adminlog( LOG_ERR, 
2095                         "Permission denied-- user not allowed to delete, \
2096 pause, or resume print job. User name: %s. Printer name: %s.",
2097                               uidtoname(server_info->utok.uid),
2098                               PRINTERNAME(snum) );
2099                 /* END_ADMIN_LOG */
2100
2101                 *errcode = WERR_ACCESS_DENIED;
2102                 return False;
2103         }
2104
2105         /* need to pause the spooled entry */
2106         ret = (*(current_printif->job_pause))(snum, pjob);
2107
2108         if (ret != 0) {
2109                 *errcode = WERR_INVALID_PARAM;
2110                 return False;
2111         }
2112
2113         /* force update the database */
2114         print_cache_flush(lp_const_servicename(snum));
2115
2116         /* Send a printer notify message */
2117
2118         notify_job_status(sharename, jobid, JOB_STATUS_PAUSED);
2119
2120         /* how do we tell if this succeeded? */
2121
2122         return True;
2123 }
2124
2125 /****************************************************************************
2126  Resume a job.
2127 ****************************************************************************/
2128
2129 bool print_job_resume(struct auth_serversupplied_info *server_info, int snum,
2130                       uint32 jobid, WERROR *errcode)
2131 {
2132         const char *sharename = lp_const_servicename(snum);
2133         struct printjob *pjob;
2134         int ret;
2135         struct printif *current_printif = get_printer_fns( snum );
2136
2137         pjob = print_job_find(sharename, jobid);
2138
2139         if (!pjob || !server_info) {
2140                 DEBUG(10, ("print_job_resume: no pjob or user for jobid %u\n",
2141                         (unsigned int)jobid ));
2142                 return False;
2143         }
2144
2145         if (!pjob->spooled || pjob->sysjob == -1) {
2146                 DEBUG(10, ("print_job_resume: not spooled or bad sysjob = %d for jobid %u\n",
2147                         (int)pjob->sysjob, (unsigned int)jobid ));
2148                 return False;
2149         }
2150
2151         if (!is_owner(server_info, lp_const_servicename(snum), jobid) &&
2152             !print_access_check(server_info, snum, JOB_ACCESS_ADMINISTER)) {
2153                 DEBUG(3, ("resume denied by security descriptor\n"));
2154                 *errcode = WERR_ACCESS_DENIED;
2155
2156                 /* BEGIN_ADMIN_LOG */
2157                 sys_adminlog( LOG_ERR, 
2158                          "Permission denied-- user not allowed to delete, \
2159 pause, or resume print job. User name: %s. Printer name: %s.",
2160                               uidtoname(server_info->utok.uid),
2161                               PRINTERNAME(snum) );
2162                 /* END_ADMIN_LOG */
2163                 return False;
2164         }
2165
2166         ret = (*(current_printif->job_resume))(snum, pjob);
2167
2168         if (ret != 0) {
2169                 *errcode = WERR_INVALID_PARAM;
2170                 return False;
2171         }
2172
2173         /* force update the database */
2174         print_cache_flush(lp_const_servicename(snum));
2175
2176         /* Send a printer notify message */
2177
2178         notify_job_status(sharename, jobid, JOB_STATUS_QUEUED);
2179
2180         return True;
2181 }
2182
2183 /****************************************************************************
2184  Write to a print file.
2185 ****************************************************************************/
2186
2187 ssize_t print_job_write(int snum, uint32 jobid, const char *buf, SMB_OFF_T pos, size_t size)
2188 {
2189         const char* sharename = lp_const_servicename(snum);
2190         int return_code;
2191         struct printjob *pjob;
2192
2193         pjob = print_job_find(sharename, jobid);
2194
2195         if (!pjob)
2196                 return -1;
2197         /* don't allow another process to get this info - it is meaningless */
2198         if (pjob->pid != sys_getpid())
2199                 return -1;
2200
2201         return_code = write_data_at_offset(pjob->fd, buf, size, pos);
2202
2203         if (return_code>0) {
2204                 pjob->size += size;
2205                 pjob_store(sharename, jobid, pjob);
2206         }
2207         return return_code;
2208 }
2209
2210 /****************************************************************************
2211  Get the queue status - do not update if db is out of date.
2212 ****************************************************************************/
2213
2214 static int get_queue_status(const char* sharename, print_status_struct *status)
2215 {
2216         fstring keystr;
2217         TDB_DATA data;
2218         struct tdb_print_db *pdb = get_print_db_byname(sharename);
2219         int len;
2220
2221         if (status) {
2222                 ZERO_STRUCTP(status);
2223         }
2224
2225         if (!pdb)
2226                 return 0;
2227
2228         if (status) {
2229                 fstr_sprintf(keystr, "STATUS/%s", sharename);
2230                 data = tdb_fetch(pdb->tdb, string_tdb_data(keystr));
2231                 if (data.dptr) {
2232                         if (data.dsize == sizeof(print_status_struct))
2233                                 /* this memcpy is ok since the status struct was 
2234                                    not packed before storing it in the tdb */
2235                                 memcpy(status, data.dptr, sizeof(print_status_struct));
2236                         SAFE_FREE(data.dptr);
2237                 }
2238         }
2239         len = tdb_fetch_int32(pdb->tdb, "INFO/total_jobs");
2240         release_print_db(pdb);
2241         return (len == -1 ? 0 : len);
2242 }
2243
2244 /****************************************************************************
2245  Determine the number of jobs in a queue.
2246 ****************************************************************************/
2247
2248 int print_queue_length(int snum, print_status_struct *pstatus)
2249 {
2250         const char* sharename = lp_const_servicename( snum );
2251         print_status_struct status;
2252         int len;
2253
2254         ZERO_STRUCT( status );
2255  
2256         /* make sure the database is up to date */
2257         if (print_cache_expired(lp_const_servicename(snum), True))
2258                 print_queue_update(snum, False);
2259  
2260         /* also fetch the queue status */
2261         memset(&status, 0, sizeof(status));
2262         len = get_queue_status(sharename, &status);
2263
2264         if (pstatus)
2265                 *pstatus = status;
2266
2267         return len;
2268 }
2269
2270 /***************************************************************************
2271  Allocate a jobid. Hold the lock for as short a time as possible.
2272 ***************************************************************************/
2273
2274 static bool allocate_print_jobid(struct tdb_print_db *pdb, int snum, const char *sharename, uint32 *pjobid)
2275 {
2276         int i;
2277         uint32 jobid;
2278
2279         *pjobid = (uint32)-1;
2280
2281         for (i = 0; i < 3; i++) {
2282                 /* Lock the database - only wait 20 seconds. */
2283                 if (tdb_lock_bystring_with_timeout(pdb->tdb, "INFO/nextjob", 20) == -1) {
2284                         DEBUG(0,("allocate_print_jobid: failed to lock printing database %s\n", sharename));
2285                         return False;
2286                 }
2287
2288                 if (!tdb_fetch_uint32(pdb->tdb, "INFO/nextjob", &jobid)) {
2289                         if (tdb_error(pdb->tdb) != TDB_ERR_NOEXIST) {
2290                                 DEBUG(0, ("allocate_print_jobid: failed to fetch INFO/nextjob for print queue %s\n",
2291                                         sharename));
2292                                 return False;
2293                         }
2294                         jobid = 0;
2295                 }
2296
2297                 jobid = NEXT_JOBID(jobid);
2298
2299                 if (tdb_store_int32(pdb->tdb, "INFO/nextjob", jobid)==-1) {
2300                         DEBUG(3, ("allocate_print_jobid: failed to store INFO/nextjob.\n"));
2301                         tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
2302                         return False;
2303                 }
2304
2305                 /* We've finished with the INFO/nextjob lock. */
2306                 tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
2307                                 
2308                 if (!print_job_exists(sharename, jobid))
2309                         break;
2310         }
2311
2312         if (i > 2) {
2313                 DEBUG(0, ("allocate_print_jobid: failed to allocate a print job for queue %s\n",
2314                         sharename));
2315                 /* Probably full... */
2316                 errno = ENOSPC;
2317                 return False;
2318         }
2319
2320         /* Store a dummy placeholder. */
2321         {
2322                 uint32_t tmp;
2323                 TDB_DATA dum;
2324                 dum.dptr = NULL;
2325                 dum.dsize = 0;
2326                 if (tdb_store(pdb->tdb, print_key(jobid, &tmp), dum,
2327                               TDB_INSERT) == -1) {
2328                         DEBUG(3, ("allocate_print_jobid: jobid (%d) failed to store placeholder.\n",
2329                                 jobid ));
2330                         return False;
2331                 }
2332         }
2333
2334         *pjobid = jobid;
2335         return True;
2336 }
2337
2338 /***************************************************************************
2339  Append a jobid to the 'jobs changed' list.
2340 ***************************************************************************/
2341
2342 static bool add_to_jobs_changed(struct tdb_print_db *pdb, uint32 jobid)
2343 {
2344         TDB_DATA data;
2345         uint32 store_jobid;
2346
2347         SIVAL(&store_jobid, 0, jobid);
2348         data.dptr = (uint8 *)&store_jobid;
2349         data.dsize = 4;
2350
2351         DEBUG(10,("add_to_jobs_changed: Added jobid %u\n", (unsigned int)jobid ));
2352
2353         return (tdb_append(pdb->tdb, string_tdb_data("INFO/jobs_changed"),
2354                            data) == 0);
2355 }
2356
2357 /***************************************************************************
2358  Start spooling a job - return the jobid.
2359 ***************************************************************************/
2360
2361 uint32 print_job_start(struct auth_serversupplied_info *server_info, int snum,
2362                        char *jobname, NT_DEVICEMODE *nt_devmode )
2363 {
2364         uint32 jobid;
2365         char *path;
2366         struct printjob pjob;
2367         const char *sharename = lp_const_servicename(snum);
2368         struct tdb_print_db *pdb = get_print_db_byname(sharename);
2369         int njobs;
2370
2371         errno = 0;
2372
2373         if (!pdb)
2374                 return (uint32)-1;
2375
2376         if (!print_access_check(server_info, snum, PRINTER_ACCESS_USE)) {
2377                 DEBUG(3, ("print_job_start: job start denied by security descriptor\n"));
2378                 release_print_db(pdb);
2379                 return (uint32)-1;
2380         }
2381
2382         if (!print_time_access_check(lp_servicename(snum))) {
2383                 DEBUG(3, ("print_job_start: job start denied by time check\n"));
2384                 release_print_db(pdb);
2385                 return (uint32)-1;
2386         }
2387
2388         path = lp_pathname(snum);
2389
2390         /* see if we have sufficient disk space */
2391         if (lp_minprintspace(snum)) {
2392                 uint64_t dspace, dsize;
2393                 if (sys_fsusage(path, &dspace, &dsize) == 0 &&
2394                     dspace < 2*(uint64_t)lp_minprintspace(snum)) {
2395                         DEBUG(3, ("print_job_start: disk space check failed.\n"));
2396                         release_print_db(pdb);
2397                         errno = ENOSPC;
2398                         return (uint32)-1;
2399                 }
2400         }
2401
2402         /* for autoloaded printers, check that the printcap entry still exists */
2403         if (lp_autoloaded(snum) && !pcap_printername_ok(lp_const_servicename(snum))) {
2404                 DEBUG(3, ("print_job_start: printer name %s check failed.\n", lp_const_servicename(snum) ));
2405                 release_print_db(pdb);
2406                 errno = ENOENT;
2407                 return (uint32)-1;
2408         }
2409
2410         /* Insure the maximum queue size is not violated */
2411         if ((njobs = print_queue_length(snum,NULL)) > lp_maxprintjobs(snum)) {
2412                 DEBUG(3, ("print_job_start: Queue %s number of jobs (%d) larger than max printjobs per queue (%d).\n",
2413                         sharename, njobs, lp_maxprintjobs(snum) ));
2414                 release_print_db(pdb);
2415                 errno = ENOSPC;
2416                 return (uint32)-1;
2417         }
2418
2419         DEBUG(10,("print_job_start: Queue %s number of jobs (%d), max printjobs = %d\n",
2420                 sharename, njobs, lp_maxprintjobs(snum) ));
2421
2422         if (!allocate_print_jobid(pdb, snum, sharename, &jobid))
2423                 goto fail;
2424
2425         /* create the database entry */
2426         
2427         ZERO_STRUCT(pjob);
2428         
2429         pjob.pid = sys_getpid();
2430         pjob.sysjob = -1;
2431         pjob.fd = -1;
2432         pjob.starttime = time(NULL);
2433         pjob.status = LPQ_SPOOLING;
2434         pjob.size = 0;
2435         pjob.spooled = False;
2436         pjob.smbjob = True;
2437         pjob.nt_devmode = nt_devmode;
2438         
2439         fstrcpy(pjob.jobname, jobname);
2440
2441         fstrcpy(pjob.user, lp_printjob_username(snum));
2442         standard_sub_advanced(sharename, server_info->sanitized_username,
2443                               path, server_info->utok.gid, 
2444                               server_info->sanitized_username,
2445                               pdb_get_domain(server_info->sam_account),
2446                               pjob.user, sizeof(pjob.user)-1);
2447         /* ensure NULL termination */
2448         pjob.user[sizeof(pjob.user)-1] = '\0';
2449
2450         fstrcpy(pjob.queuename, lp_const_servicename(snum));
2451
2452         /* we have a job entry - now create the spool file */
2453         slprintf(pjob.filename, sizeof(pjob.filename)-1, "%s/%s%.8u.XXXXXX", 
2454                  path, PRINT_SPOOL_PREFIX, (unsigned int)jobid);
2455         pjob.fd = smb_mkstemp(pjob.filename);
2456
2457         if (pjob.fd == -1) {
2458                 if (errno == EACCES) {
2459                         /* Common setup error, force a report. */
2460                         DEBUG(0, ("print_job_start: insufficient permissions \
2461 to open spool file %s.\n", pjob.filename));
2462                 } else {
2463                         /* Normal case, report at level 3 and above. */
2464                         DEBUG(3, ("print_job_start: can't open spool file %s,\n", pjob.filename));
2465                         DEBUGADD(3, ("errno = %d (%s).\n", errno, strerror(errno)));
2466                 }
2467                 goto fail;
2468         }
2469
2470         pjob_store(sharename, jobid, &pjob);
2471
2472         /* Update the 'jobs changed' entry used by print_queue_status. */
2473         add_to_jobs_changed(pdb, jobid);
2474
2475         /* Ensure we keep a rough count of the number of total jobs... */
2476         tdb_change_int32_atomic(pdb->tdb, "INFO/total_jobs", &njobs, 1);
2477
2478         release_print_db(pdb);
2479
2480         return jobid;
2481
2482  fail:
2483         if (jobid != -1)
2484                 pjob_delete(sharename, jobid);
2485
2486         release_print_db(pdb);
2487
2488         DEBUG(3, ("print_job_start: returning fail. Error = %s\n", strerror(errno) ));
2489         return (uint32)-1;
2490 }
2491
2492 /****************************************************************************
2493  Update the number of pages spooled to jobid
2494 ****************************************************************************/
2495
2496 void print_job_endpage(int snum, uint32 jobid)
2497 {
2498         const char* sharename = lp_const_servicename(snum);
2499         struct printjob *pjob;
2500
2501         pjob = print_job_find(sharename, jobid);
2502         if (!pjob)
2503                 return;
2504         /* don't allow another process to get this info - it is meaningless */
2505         if (pjob->pid != sys_getpid())
2506                 return;
2507
2508         pjob->page_count++;
2509         pjob_store(sharename, jobid, pjob);
2510 }
2511
2512 /****************************************************************************
2513  Print a file - called on closing the file. This spools the job.
2514  If normal close is false then we're tearing down the jobs - treat as an
2515  error.
2516 ****************************************************************************/
2517
2518 bool print_job_end(int snum, uint32 jobid, enum file_close_type close_type)
2519 {
2520         const char* sharename = lp_const_servicename(snum);
2521         struct printjob *pjob;
2522         int ret;
2523         SMB_STRUCT_STAT sbuf;
2524         struct printif *current_printif = get_printer_fns( snum );
2525
2526         pjob = print_job_find(sharename, jobid);
2527
2528         if (!pjob)
2529                 return False;
2530
2531         if (pjob->spooled || pjob->pid != sys_getpid())
2532                 return False;
2533
2534         if ((close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) &&
2535                                 (sys_fstat(pjob->fd, &sbuf) == 0)) {
2536                 pjob->size = sbuf.st_size;
2537                 close(pjob->fd);
2538                 pjob->fd = -1;
2539         } else {
2540
2541                 /* 
2542                  * Not a normal close or we couldn't stat the job file,
2543                  * so something has gone wrong. Cleanup.
2544                  */
2545                 close(pjob->fd);
2546                 pjob->fd = -1;
2547                 DEBUG(3,("print_job_end: failed to stat file for jobid %d\n", jobid ));
2548                 goto fail;
2549         }
2550
2551         /* Technically, this is not quite right. If the printer has a separator
2552          * page turned on, the NT spooler prints the separator page even if the
2553          * print job is 0 bytes. 010215 JRR */
2554         if (pjob->size == 0 || pjob->status == LPQ_DELETING) {
2555                 /* don't bother spooling empty files or something being deleted. */
2556                 DEBUG(5,("print_job_end: canceling spool of %s (%s)\n",
2557                         pjob->filename, pjob->size ? "deleted" : "zero length" ));
2558                 unlink(pjob->filename);
2559                 pjob_delete(sharename, jobid);
2560                 return True;
2561         }
2562
2563         pjob->smbjob = jobid;
2564
2565         ret = (*(current_printif->job_submit))(snum, pjob);
2566
2567         if (ret)
2568                 goto fail;
2569
2570         /* The print job has been successfully handed over to the back-end */
2571         
2572         pjob->spooled = True;
2573         pjob->status = LPQ_QUEUED;
2574         pjob_store(sharename, jobid, pjob);
2575         
2576         /* make sure the database is up to date */
2577         if (print_cache_expired(lp_const_servicename(snum), True))
2578                 print_queue_update(snum, False);
2579         
2580         return True;
2581
2582 fail:
2583
2584         /* The print job was not successfully started. Cleanup */
2585         /* Still need to add proper error return propagation! 010122:JRR */
2586         unlink(pjob->filename);
2587         pjob_delete(sharename, jobid);
2588         return False;
2589 }
2590
2591 /****************************************************************************
2592  Get a snapshot of jobs in the system without traversing.
2593 ****************************************************************************/
2594
2595 static bool get_stored_queue_info(struct tdb_print_db *pdb, int snum, int *pcount, print_queue_struct **ppqueue)
2596 {
2597         TDB_DATA data, cgdata;
2598         print_queue_struct *queue = NULL;
2599         uint32 qcount = 0;
2600         uint32 extra_count = 0;
2601         int total_count = 0;
2602         size_t len = 0;
2603         uint32 i;
2604         int max_reported_jobs = lp_max_reported_jobs(snum);
2605         bool ret = False;
2606         const char* sharename = lp_servicename(snum);
2607
2608         /* make sure the database is up to date */
2609         if (print_cache_expired(lp_const_servicename(snum), True))
2610                 print_queue_update(snum, False);
2611  
2612         *pcount = 0;
2613         *ppqueue = NULL;
2614
2615         ZERO_STRUCT(data);
2616         ZERO_STRUCT(cgdata);
2617
2618         /* Get the stored queue data. */
2619         data = tdb_fetch(pdb->tdb, string_tdb_data("INFO/linear_queue_array"));
2620         
2621         if (data.dptr && data.dsize >= sizeof(qcount))
2622                 len += tdb_unpack(data.dptr + len, data.dsize - len, "d", &qcount);
2623                 
2624         /* Get the changed jobs list. */
2625         cgdata = tdb_fetch(pdb->tdb, string_tdb_data("INFO/jobs_changed"));
2626         if (cgdata.dptr != NULL && (cgdata.dsize % 4 == 0))
2627                 extra_count = cgdata.dsize/4;
2628
2629         DEBUG(5,("get_stored_queue_info: qcount = %u, extra_count = %u\n", (unsigned int)qcount, (unsigned int)extra_count));
2630
2631         /* Allocate the queue size. */
2632         if (qcount == 0 && extra_count == 0)
2633                 goto out;
2634
2635         if ((queue = SMB_MALLOC_ARRAY(print_queue_struct, qcount + extra_count)) == NULL)
2636                 goto out;
2637
2638         /* Retrieve the linearised queue data. */
2639
2640         for( i  = 0; i < qcount; i++) {
2641                 uint32 qjob, qsize, qpage_count, qstatus, qpriority, qtime;
2642                 len += tdb_unpack(data.dptr + len, data.dsize - len, "ddddddff",
2643                                 &qjob,
2644                                 &qsize,
2645                                 &qpage_count,
2646                                 &qstatus,
2647                                 &qpriority,
2648                                 &qtime,
2649                                 queue[i].fs_user,
2650                                 queue[i].fs_file);
2651                 queue[i].job = qjob;
2652                 queue[i].size = qsize;
2653                 queue[i].page_count = qpage_count;
2654                 queue[i].status = qstatus;
2655                 queue[i].priority = qpriority;
2656                 queue[i].time = qtime;
2657         }
2658
2659         total_count = qcount;
2660
2661         /* Add in the changed jobids. */
2662         for( i  = 0; i < extra_count; i++) {
2663                 uint32 jobid;
2664                 struct printjob *pjob;
2665
2666                 jobid = IVAL(cgdata.dptr, i*4);
2667                 DEBUG(5,("get_stored_queue_info: changed job = %u\n", (unsigned int)jobid));
2668                 pjob = print_job_find(lp_const_servicename(snum), jobid);
2669                 if (!pjob) {
2670                         DEBUG(5,("get_stored_queue_info: failed to find changed job = %u\n", (unsigned int)jobid));
2671                         remove_from_jobs_changed(sharename, jobid);
2672                         continue;
2673                 }
2674
2675                 queue[total_count].job = jobid;
2676                 queue[total_count].size = pjob->size;
2677                 queue[total_count].page_count = pjob->page_count;
2678                 queue[total_count].status = pjob->status;
2679                 queue[total_count].priority = 1;
2680                 queue[total_count].time = pjob->starttime;
2681                 fstrcpy(queue[total_count].fs_user, pjob->user);
2682                 fstrcpy(queue[total_count].fs_file, pjob->jobname);
2683                 total_count++;
2684         }
2685
2686         /* Sort the queue by submission time otherwise they are displayed
2687            in hash order. */
2688
2689         qsort(queue, total_count, sizeof(print_queue_struct), QSORT_CAST(printjob_comp));
2690
2691         DEBUG(5,("get_stored_queue_info: total_count = %u\n", (unsigned int)total_count));
2692
2693         if (max_reported_jobs && total_count > max_reported_jobs)
2694                 total_count = max_reported_jobs;
2695
2696         *ppqueue = queue;
2697         *pcount = total_count;
2698
2699         ret = True;
2700
2701   out:
2702
2703         SAFE_FREE(data.dptr);
2704         SAFE_FREE(cgdata.dptr);
2705         return ret;
2706 }
2707
2708 /****************************************************************************
2709  Get a printer queue listing.
2710  set queue = NULL and status = NULL if you just want to update the cache
2711 ****************************************************************************/
2712
2713 int print_queue_status(int snum, 
2714                        print_queue_struct **ppqueue,
2715                        print_status_struct *status)
2716 {
2717         fstring keystr;
2718         TDB_DATA data, key;
2719         const char *sharename;
2720         struct tdb_print_db *pdb;
2721         int count = 0;
2722
2723         /* make sure the database is up to date */
2724
2725         if (print_cache_expired(lp_const_servicename(snum), True))
2726                 print_queue_update(snum, False);
2727
2728         /* return if we are done */
2729         if ( !ppqueue || !status )
2730                 return 0;
2731
2732         *ppqueue = NULL;
2733         sharename = lp_const_servicename(snum);
2734         pdb = get_print_db_byname(sharename);
2735
2736         if (!pdb)
2737                 return 0;
2738
2739         /*
2740          * Fetch the queue status.  We must do this first, as there may
2741          * be no jobs in the queue.
2742          */
2743
2744         ZERO_STRUCTP(status);
2745         slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", sharename);
2746         key = string_tdb_data(keystr);
2747
2748         data = tdb_fetch(pdb->tdb, key);
2749         if (data.dptr) {
2750                 if (data.dsize == sizeof(*status)) {
2751                         /* this memcpy is ok since the status struct was 
2752                            not packed before storing it in the tdb */
2753                         memcpy(status, data.dptr, sizeof(*status));
2754                 }
2755                 SAFE_FREE(data.dptr);
2756         }
2757
2758         /*
2759          * Now, fetch the print queue information.  We first count the number
2760          * of entries, and then only retrieve the queue if necessary.
2761          */
2762
2763         if (!get_stored_queue_info(pdb, snum, &count, ppqueue)) {
2764                 release_print_db(pdb);
2765                 return 0;
2766         }
2767
2768         release_print_db(pdb);
2769         return count;
2770 }
2771
2772 /****************************************************************************
2773  Pause a queue.
2774 ****************************************************************************/
2775
2776 bool print_queue_pause(struct auth_serversupplied_info *server_info, int snum,
2777                        WERROR *errcode)
2778 {
2779         int ret;
2780         struct printif *current_printif = get_printer_fns( snum );
2781         
2782         if (!print_access_check(server_info, snum,
2783                                 PRINTER_ACCESS_ADMINISTER)) {
2784                 *errcode = WERR_ACCESS_DENIED;
2785                 return False;
2786         }
2787         
2788
2789         become_root();
2790                 
2791         ret = (*(current_printif->queue_pause))(snum);
2792
2793         unbecome_root();
2794                 
2795         if (ret != 0) {
2796                 *errcode = WERR_INVALID_PARAM;
2797                 return False;
2798         }
2799
2800         /* force update the database */
2801         print_cache_flush(lp_const_servicename(snum));
2802
2803         /* Send a printer notify message */
2804
2805         notify_printer_status(snum, PRINTER_STATUS_PAUSED);
2806
2807         return True;
2808 }
2809
2810 /****************************************************************************
2811  Resume a queue.
2812 ****************************************************************************/
2813
2814 bool print_queue_resume(struct auth_serversupplied_info *server_info, int snum,
2815                         WERROR *errcode)
2816 {
2817         int ret;
2818         struct printif *current_printif = get_printer_fns( snum );
2819
2820         if (!print_access_check(server_info, snum,
2821                                 PRINTER_ACCESS_ADMINISTER)) {
2822                 *errcode = WERR_ACCESS_DENIED;
2823                 return False;
2824         }
2825         
2826         become_root();
2827                 
2828         ret = (*(current_printif->queue_resume))(snum);
2829
2830         unbecome_root();
2831                 
2832         if (ret != 0) {
2833                 *errcode = WERR_INVALID_PARAM;
2834                 return False;
2835         }
2836
2837         /* make sure the database is up to date */
2838         if (print_cache_expired(lp_const_servicename(snum), True))
2839                 print_queue_update(snum, True);
2840
2841         /* Send a printer notify message */
2842
2843         notify_printer_status(snum, PRINTER_STATUS_OK);
2844
2845         return True;
2846 }
2847
2848 /****************************************************************************
2849  Purge a queue - implemented by deleting all jobs that we can delete.
2850 ****************************************************************************/
2851
2852 bool print_queue_purge(struct auth_serversupplied_info *server_info, int snum,
2853                        WERROR *errcode)
2854 {
2855         print_queue_struct *queue;
2856         print_status_struct status;
2857         int njobs, i;
2858         bool can_job_admin;
2859
2860         /* Force and update so the count is accurate (i.e. not a cached count) */
2861         print_queue_update(snum, True);
2862         
2863         can_job_admin = print_access_check(server_info, snum,
2864                                            JOB_ACCESS_ADMINISTER);
2865         njobs = print_queue_status(snum, &queue, &status);
2866         
2867         if ( can_job_admin )
2868                 become_root();
2869
2870         for (i=0;i<njobs;i++) {
2871                 bool owner = is_owner(server_info, lp_const_servicename(snum),
2872                                       queue[i].job);
2873
2874                 if (owner || can_job_admin) {
2875                         print_job_delete1(snum, queue[i].job);
2876                 }
2877         }
2878         
2879         if ( can_job_admin )
2880                 unbecome_root();
2881
2882         /* update the cache */
2883         print_queue_update( snum, True );
2884
2885         SAFE_FREE(queue);
2886
2887         return True;
2888 }