Fix bug #5688 LPQ process is orphaned if socket address parameter is invalid
[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         /* Use local variables for this as we don't
1398          * need to save the parent side of this, just
1399          * ensure it closes when the process exits.
1400          */
1401         int pause_pipe[2];
1402
1403         DEBUG(3,("start_background_queue: Starting background LPQ thread\n"));
1404
1405         if (pipe(pause_pipe) == -1) {
1406                 DEBUG(5,("start_background_queue: cannot create pipe. %s\n", strerror(errno) ));
1407                 exit(1);
1408         }
1409
1410         background_lpq_updater_pid = sys_fork();
1411
1412         if (background_lpq_updater_pid == -1) {
1413                 DEBUG(5,("start_background_queue: background LPQ thread failed to start. %s\n", strerror(errno) ));
1414                 exit(1);
1415         }
1416
1417         if(background_lpq_updater_pid == 0) {
1418                 /* Child. */
1419                 DEBUG(5,("start_background_queue: background LPQ thread started\n"));
1420
1421                 close(pause_pipe[0]);
1422                 pause_pipe[0] = -1;
1423
1424                 if (!reinit_after_fork(smbd_messaging_context(), true)) {
1425                         DEBUG(0,("reinit_after_fork() failed\n"));
1426                         smb_panic("reinit_after_fork() failed");
1427                 }
1428
1429                 claim_connection( NULL, "smbd lpq backend",
1430                         FLAG_MSG_GENERAL|FLAG_MSG_SMBD|FLAG_MSG_PRINT_GENERAL);
1431
1432                 if (!locking_init()) {
1433                         exit(1);
1434                 }
1435
1436                 messaging_register(smbd_messaging_context(), NULL,
1437                                    MSG_PRINTER_UPDATE, print_queue_receive);
1438
1439                 DEBUG(5,("start_background_queue: background LPQ thread waiting for messages\n"));
1440                 while (1) {
1441                         fd_set pause_fds;
1442                         int pause_select;
1443
1444                         FD_ZERO(&pause_fds);
1445                         FD_SET(pause_pipe[1], &pause_fds);
1446                         pause_select = sys_select(pause_pipe[1]+1, &pause_fds, NULL, NULL, NULL);
1447                         /* If pause_pipe[0] is closed it means the parent smbd
1448                          * and children exited or aborted. */
1449                         if (pause_select == 1) {
1450                                 exit_server_cleanly(NULL);
1451                         }
1452
1453                         /* check for some essential signals first */
1454
1455                         if (got_sig_term) {
1456                                 exit_server_cleanly(NULL);
1457                         }
1458
1459                         if (reload_after_sighup) {
1460                                 change_to_root_user();
1461                                 DEBUG(1,("Reloading services after SIGHUP\n"));
1462                                 reload_services(False);
1463                                 reload_after_sighup = 0;
1464                         }
1465
1466                         /* now check for messages */
1467
1468                         DEBUG(10,("start_background_queue: background LPQ thread got a message\n"));
1469                         message_dispatch(smbd_messaging_context());
1470
1471                         /* process any pending print change notify messages */
1472
1473                         print_notify_send_messages(smbd_messaging_context(),
1474                                                    0);
1475                 }
1476         }
1477
1478         close(pause_pipe[1]);
1479 }
1480
1481 /****************************************************************************
1482 update the internal database from the system print queue for a queue
1483 ****************************************************************************/
1484
1485 static void print_queue_update(int snum, bool force)
1486 {
1487         fstring key;
1488         fstring sharename;
1489         char *lpqcommand = NULL;
1490         char *lprmcommand = NULL;
1491         uint8 *buffer = NULL;
1492         size_t len = 0;
1493         size_t newlen;
1494         struct tdb_print_db *pdb;
1495         int type;
1496         struct printif *current_printif;
1497         TALLOC_CTX *ctx = talloc_tos();
1498
1499         fstrcpy( sharename, lp_const_servicename(snum));
1500
1501         /* don't strip out characters like '$' from the printername */
1502
1503         lpqcommand = talloc_string_sub2(ctx,
1504                         lp_lpqcommand(snum),
1505                         "%p",
1506                         PRINTERNAME(snum),
1507                         false, false, false);
1508         if (!lpqcommand) {
1509                 return;
1510         }
1511         lpqcommand = talloc_sub_advanced(ctx,
1512                         lp_servicename(snum),
1513                         current_user_info.unix_name,
1514                         "",
1515                         current_user.ut.gid,
1516                         get_current_username(),
1517                         current_user_info.domain,
1518                         lpqcommand);
1519         if (!lpqcommand) {
1520                 return;
1521         }
1522
1523         lprmcommand = talloc_string_sub2(ctx,
1524                         lp_lprmcommand(snum),
1525                         "%p",
1526                         PRINTERNAME(snum),
1527                         false, false, false);
1528         if (!lprmcommand) {
1529                 return;
1530         }
1531         lprmcommand = talloc_sub_advanced(ctx,
1532                         lp_servicename(snum),
1533                         current_user_info.unix_name,
1534                         "",
1535                         current_user.ut.gid,
1536                         get_current_username(),
1537                         current_user_info.domain,
1538                         lprmcommand);
1539         if (!lprmcommand) {
1540                 return;
1541         }
1542
1543         /*
1544          * Make sure that the background queue process exists.
1545          * Otherwise just do the update ourselves
1546          */
1547
1548         if ( force || background_lpq_updater_pid == -1 ) {
1549                 DEBUG(4,("print_queue_update: updating queue [%s] myself\n", sharename));
1550                 current_printif = get_printer_fns( snum );
1551                 print_queue_update_with_lock( sharename, current_printif, lpqcommand, lprmcommand );
1552
1553                 return;
1554         }
1555
1556         type = lp_printing(snum);
1557
1558         /* get the length */
1559
1560         len = tdb_pack( NULL, 0, "fdPP",
1561                 sharename,
1562                 type,
1563                 lpqcommand,
1564                 lprmcommand );
1565
1566         buffer = SMB_XMALLOC_ARRAY( uint8, len );
1567
1568         /* now pack the buffer */
1569         newlen = tdb_pack( buffer, len, "fdPP",
1570                 sharename,
1571                 type,
1572                 lpqcommand,
1573                 lprmcommand );
1574
1575         SMB_ASSERT( newlen == len );
1576
1577         DEBUG(10,("print_queue_update: Sending message -> printer = %s, "
1578                 "type = %d, lpq command = [%s] lprm command = [%s]\n", 
1579                 sharename, type, lpqcommand, lprmcommand ));
1580
1581         /* here we set a msg pending record for other smbd processes 
1582            to throttle the number of duplicate print_queue_update msgs
1583            sent.  */
1584
1585         pdb = get_print_db_byname(sharename);
1586         if (!pdb) {
1587                 SAFE_FREE(buffer);
1588                 return;
1589         }
1590
1591         snprintf(key, sizeof(key), "MSG_PENDING/%s", sharename);
1592
1593         if ( !tdb_store_uint32( pdb->tdb, key, time(NULL) ) ) {
1594                 /* log a message but continue on */
1595
1596                 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1597                         sharename));
1598         }
1599
1600         release_print_db( pdb );
1601
1602         /* finally send the message */
1603         
1604         messaging_send_buf(smbd_messaging_context(),
1605                            pid_to_procid(background_lpq_updater_pid),
1606                            MSG_PRINTER_UPDATE, (uint8 *)buffer, len);
1607
1608         SAFE_FREE( buffer );
1609
1610         return;
1611 }
1612
1613 /****************************************************************************
1614  Create/Update an entry in the print tdb that will allow us to send notify
1615  updates only to interested smbd's. 
1616 ****************************************************************************/
1617
1618 bool print_notify_register_pid(int snum)
1619 {
1620         TDB_DATA data;
1621         struct tdb_print_db *pdb = NULL;
1622         TDB_CONTEXT *tdb = NULL;
1623         const char *printername;
1624         uint32 mypid = (uint32)sys_getpid();
1625         bool ret = False;
1626         size_t i;
1627
1628         /* if (snum == -1), then the change notify request was
1629            on a print server handle and we need to register on
1630            all print queus */
1631            
1632         if (snum == -1) 
1633         {
1634                 int num_services = lp_numservices();
1635                 int idx;
1636                 
1637                 for ( idx=0; idx<num_services; idx++ ) {
1638                         if (lp_snum_ok(idx) && lp_print_ok(idx) )
1639                                 print_notify_register_pid(idx);
1640                 }
1641                 
1642                 return True;
1643         }
1644         else /* register for a specific printer */
1645         {
1646                 printername = lp_const_servicename(snum);
1647                 pdb = get_print_db_byname(printername);
1648                 if (!pdb)
1649                         return False;
1650                 tdb = pdb->tdb;
1651         }
1652
1653         if (tdb_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) == -1) {
1654                 DEBUG(0,("print_notify_register_pid: Failed to lock printer %s\n",
1655                                         printername));
1656                 if (pdb)
1657                         release_print_db(pdb);
1658                 return False;
1659         }
1660
1661         data = get_printer_notify_pid_list( tdb, printername, True );
1662
1663         /* Add ourselves and increase the refcount. */
1664
1665         for (i = 0; i < data.dsize; i += 8) {
1666                 if (IVAL(data.dptr,i) == mypid) {
1667                         uint32 new_refcount = IVAL(data.dptr, i+4) + 1;
1668                         SIVAL(data.dptr, i+4, new_refcount);
1669                         break;
1670                 }
1671         }
1672
1673         if (i == data.dsize) {
1674                 /* We weren't in the list. Realloc. */
1675                 data.dptr = (uint8 *)SMB_REALLOC(data.dptr, data.dsize + 8);
1676                 if (!data.dptr) {
1677                         DEBUG(0,("print_notify_register_pid: Relloc fail for printer %s\n",
1678                                                 printername));
1679                         goto done;
1680                 }
1681                 data.dsize += 8;
1682                 SIVAL(data.dptr,data.dsize - 8,mypid);
1683                 SIVAL(data.dptr,data.dsize - 4,1); /* Refcount. */
1684         }
1685
1686         /* Store back the record. */
1687         if (tdb_store_bystring(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) == -1) {
1688                 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1689 list for printer %s\n", printername));
1690                 goto done;
1691         }
1692
1693         ret = True;
1694
1695  done:
1696
1697         tdb_unlock_bystring(tdb, NOTIFY_PID_LIST_KEY);
1698         if (pdb)
1699                 release_print_db(pdb);
1700         SAFE_FREE(data.dptr);
1701         return ret;
1702 }
1703
1704 /****************************************************************************
1705  Update an entry in the print tdb that will allow us to send notify
1706  updates only to interested smbd's. 
1707 ****************************************************************************/
1708
1709 bool print_notify_deregister_pid(int snum)
1710 {
1711         TDB_DATA data;
1712         struct tdb_print_db *pdb = NULL;
1713         TDB_CONTEXT *tdb = NULL;
1714         const char *printername;
1715         uint32 mypid = (uint32)sys_getpid();
1716         size_t i;
1717         bool ret = False;
1718
1719         /* if ( snum == -1 ), we are deregister a print server handle
1720            which means to deregister on all print queues */
1721            
1722         if (snum == -1) 
1723         {
1724                 int num_services = lp_numservices();
1725                 int idx;
1726                 
1727                 for ( idx=0; idx<num_services; idx++ ) {
1728                         if ( lp_snum_ok(idx) && lp_print_ok(idx) )
1729                                 print_notify_deregister_pid(idx);
1730                 }
1731                 
1732                 return True;
1733         }
1734         else /* deregister a specific printer */
1735         {
1736                 printername = lp_const_servicename(snum);
1737                 pdb = get_print_db_byname(printername);
1738                 if (!pdb)
1739                         return False;
1740                 tdb = pdb->tdb;
1741         }
1742
1743         if (tdb_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) == -1) {
1744                 DEBUG(0,("print_notify_register_pid: Failed to lock \
1745 printer %s database\n", printername));
1746                 if (pdb)
1747                         release_print_db(pdb);
1748                 return False;
1749         }
1750
1751         data = get_printer_notify_pid_list( tdb, printername, True );
1752
1753         /* Reduce refcount. Remove ourselves if zero. */
1754
1755         for (i = 0; i < data.dsize; ) {
1756                 if (IVAL(data.dptr,i) == mypid) {
1757                         uint32 refcount = IVAL(data.dptr, i+4);
1758
1759                         refcount--;
1760
1761                         if (refcount == 0) {
1762                                 if (data.dsize - i > 8)
1763                                         memmove( &data.dptr[i], &data.dptr[i+8], data.dsize - i - 8);
1764                                 data.dsize -= 8;
1765                                 continue;
1766                         }
1767                         SIVAL(data.dptr, i+4, refcount);
1768                 }
1769
1770                 i += 8;
1771         }
1772
1773         if (data.dsize == 0)
1774                 SAFE_FREE(data.dptr);
1775
1776         /* Store back the record. */
1777         if (tdb_store_bystring(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) == -1) {
1778                 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1779 list for printer %s\n", printername));
1780                 goto done;
1781         }
1782
1783         ret = True;
1784
1785   done:
1786
1787         tdb_unlock_bystring(tdb, NOTIFY_PID_LIST_KEY);
1788         if (pdb)
1789                 release_print_db(pdb);
1790         SAFE_FREE(data.dptr);
1791         return ret;
1792 }
1793
1794 /****************************************************************************
1795  Check if a jobid is valid. It is valid if it exists in the database.
1796 ****************************************************************************/
1797
1798 bool print_job_exists(const char* sharename, uint32 jobid)
1799 {
1800         struct tdb_print_db *pdb = get_print_db_byname(sharename);
1801         bool ret;
1802         uint32_t tmp;
1803
1804         if (!pdb)
1805                 return False;
1806         ret = tdb_exists(pdb->tdb, print_key(jobid, &tmp));
1807         release_print_db(pdb);
1808         return ret;
1809 }
1810
1811 /****************************************************************************
1812  Give the fd used for a jobid.
1813 ****************************************************************************/
1814
1815 int print_job_fd(const char* sharename, uint32 jobid)
1816 {
1817         struct printjob *pjob = print_job_find(sharename, jobid);
1818         if (!pjob)
1819                 return -1;
1820         /* don't allow another process to get this info - it is meaningless */
1821         if (pjob->pid != sys_getpid())
1822                 return -1;
1823         return pjob->fd;
1824 }
1825
1826 /****************************************************************************
1827  Give the filename used for a jobid.
1828  Only valid for the process doing the spooling and when the job
1829  has not been spooled.
1830 ****************************************************************************/
1831
1832 char *print_job_fname(const char* sharename, uint32 jobid)
1833 {
1834         struct printjob *pjob = print_job_find(sharename, jobid);
1835         if (!pjob || pjob->spooled || pjob->pid != sys_getpid())
1836                 return NULL;
1837         return pjob->filename;
1838 }
1839
1840
1841 /****************************************************************************
1842  Give the filename used for a jobid.
1843  Only valid for the process doing the spooling and when the job
1844  has not been spooled.
1845 ****************************************************************************/
1846
1847 NT_DEVICEMODE *print_job_devmode(const char* sharename, uint32 jobid)
1848 {
1849         struct printjob *pjob = print_job_find(sharename, jobid);
1850         
1851         if ( !pjob )
1852                 return NULL;
1853                 
1854         return pjob->nt_devmode;
1855 }
1856
1857 /****************************************************************************
1858  Set the place in the queue for a job.
1859 ****************************************************************************/
1860
1861 bool print_job_set_place(const char *sharename, uint32 jobid, int place)
1862 {
1863         DEBUG(2,("print_job_set_place not implemented yet\n"));
1864         return False;
1865 }
1866
1867 /****************************************************************************
1868  Set the name of a job. Only possible for owner.
1869 ****************************************************************************/
1870
1871 bool print_job_set_name(const char *sharename, uint32 jobid, char *name)
1872 {
1873         struct printjob *pjob;
1874
1875         pjob = print_job_find(sharename, jobid);
1876         if (!pjob || pjob->pid != sys_getpid())
1877                 return False;
1878
1879         fstrcpy(pjob->jobname, name);
1880         return pjob_store(sharename, jobid, pjob);
1881 }
1882
1883 /***************************************************************************
1884  Remove a jobid from the 'jobs changed' list.
1885 ***************************************************************************/
1886
1887 static bool remove_from_jobs_changed(const char* sharename, uint32 jobid)
1888 {
1889         struct tdb_print_db *pdb = get_print_db_byname(sharename);
1890         TDB_DATA data, key;
1891         size_t job_count, i;
1892         bool ret = False;
1893         bool gotlock = False;
1894
1895         if (!pdb) {
1896                 return False;
1897         }
1898
1899         ZERO_STRUCT(data);
1900
1901         key = string_tdb_data("INFO/jobs_changed");
1902
1903         if (tdb_chainlock_with_timeout(pdb->tdb, key, 5) == -1)
1904                 goto out;
1905
1906         gotlock = True;
1907
1908         data = tdb_fetch(pdb->tdb, key);
1909
1910         if (data.dptr == NULL || data.dsize == 0 || (data.dsize % 4 != 0))
1911                 goto out;
1912
1913         job_count = data.dsize / 4;
1914         for (i = 0; i < job_count; i++) {
1915                 uint32 ch_jobid;
1916
1917                 ch_jobid = IVAL(data.dptr, i*4);
1918                 if (ch_jobid == jobid) {
1919                         if (i < job_count -1 )
1920                                 memmove(data.dptr + (i*4), data.dptr + (i*4) + 4, (job_count - i - 1)*4 );
1921                         data.dsize -= 4;
1922                         if (tdb_store(pdb->tdb, key, data, TDB_REPLACE) == -1)
1923                                 goto out;
1924                         break;
1925                 }
1926         }
1927
1928         ret = True;
1929   out:
1930
1931         if (gotlock)
1932                 tdb_chainunlock(pdb->tdb, key);
1933         SAFE_FREE(data.dptr);
1934         release_print_db(pdb);
1935         if (ret)
1936                 DEBUG(10,("remove_from_jobs_changed: removed jobid %u\n", (unsigned int)jobid ));
1937         else
1938                 DEBUG(10,("remove_from_jobs_changed: Failed to remove jobid %u\n", (unsigned int)jobid ));
1939         return ret;
1940 }
1941
1942 /****************************************************************************
1943  Delete a print job - don't update queue.
1944 ****************************************************************************/
1945
1946 static bool print_job_delete1(int snum, uint32 jobid)
1947 {
1948         const char* sharename = lp_const_servicename(snum);
1949         struct printjob *pjob = print_job_find(sharename, jobid);
1950         int result = 0;
1951         struct printif *current_printif = get_printer_fns( snum );
1952
1953         if (!pjob)
1954                 return False;
1955
1956         /*
1957          * If already deleting just return.
1958          */
1959
1960         if (pjob->status == LPQ_DELETING)
1961                 return True;
1962
1963         /* Hrm - we need to be able to cope with deleting a job before it
1964            has reached the spooler.  Just mark it as LPQ_DELETING and 
1965            let the print_queue_update() code rmeove the record */
1966            
1967
1968         if (pjob->sysjob == -1) {
1969                 DEBUG(5, ("attempt to delete job %u not seen by lpr\n", (unsigned int)jobid));
1970         }
1971
1972         /* Set the tdb entry to be deleting. */
1973
1974         pjob->status = LPQ_DELETING;
1975         pjob_store(sharename, jobid, pjob);
1976
1977         if (pjob->spooled && pjob->sysjob != -1) 
1978         {
1979                 result = (*(current_printif->job_delete))(
1980                         PRINTERNAME(snum),
1981                         lp_lprmcommand(snum), 
1982                         pjob);
1983
1984                 /* Delete the tdb entry if the delete succeeded or the job hasn't
1985                    been spooled. */
1986
1987                 if (result == 0) {
1988                         struct tdb_print_db *pdb = get_print_db_byname(sharename);
1989                         int njobs = 1;
1990
1991                         if (!pdb)
1992                                 return False;
1993                         pjob_delete(sharename, jobid);
1994                         /* Ensure we keep a rough count of the number of total jobs... */
1995                         tdb_change_int32_atomic(pdb->tdb, "INFO/total_jobs", &njobs, -1);
1996                         release_print_db(pdb);
1997                 }
1998         }
1999
2000         remove_from_jobs_changed( sharename, jobid );
2001
2002         return (result == 0);
2003 }
2004
2005 /****************************************************************************
2006  Return true if the current user owns the print job.
2007 ****************************************************************************/
2008
2009 static bool is_owner(struct auth_serversupplied_info *server_info,
2010                      const char *servicename,
2011                      uint32 jobid)
2012 {
2013         struct printjob *pjob = print_job_find(servicename, jobid);
2014
2015         if (!pjob || !server_info)
2016                 return False;
2017
2018         return strequal(pjob->user, server_info->sanitized_username);
2019 }
2020
2021 /****************************************************************************
2022  Delete a print job.
2023 ****************************************************************************/
2024
2025 bool print_job_delete(struct auth_serversupplied_info *server_info, int snum,
2026                       uint32 jobid, WERROR *errcode)
2027 {
2028         const char* sharename = lp_const_servicename( snum );
2029         struct printjob *pjob;
2030         bool    owner;
2031         char    *fname;
2032
2033         *errcode = WERR_OK;
2034                 
2035         owner = is_owner(server_info, lp_const_servicename(snum), jobid);
2036         
2037         /* Check access against security descriptor or whether the user
2038            owns their job. */
2039
2040         if (!owner && 
2041             !print_access_check(server_info, snum, JOB_ACCESS_ADMINISTER)) {
2042                 DEBUG(3, ("delete denied by security descriptor\n"));
2043                 *errcode = WERR_ACCESS_DENIED;
2044
2045                 /* BEGIN_ADMIN_LOG */
2046                 sys_adminlog( LOG_ERR, 
2047                               "Permission denied-- user not allowed to delete, \
2048 pause, or resume print job. User name: %s. Printer name: %s.",
2049                               uidtoname(server_info->utok.uid),
2050                               PRINTERNAME(snum) );
2051                 /* END_ADMIN_LOG */
2052
2053                 return False;
2054         }
2055
2056         /* 
2057          * get the spooled filename of the print job
2058          * if this works, then the file has not been spooled
2059          * to the underlying print system.  Just delete the 
2060          * spool file & return.
2061          */
2062          
2063         if ( (fname = print_job_fname( sharename, jobid )) != NULL )
2064         {
2065                 /* remove the spool file */
2066                 DEBUG(10,("print_job_delete: Removing spool file [%s]\n", fname ));
2067                 if ( unlink( fname ) == -1 ) {
2068                         *errcode = map_werror_from_unix(errno);
2069                         return False;
2070                 }
2071         }
2072         
2073         if (!print_job_delete1(snum, jobid)) {
2074                 *errcode = WERR_ACCESS_DENIED;
2075                 return False;
2076         }
2077
2078         /* force update the database and say the delete failed if the
2079            job still exists */
2080
2081         print_queue_update(snum, True);
2082         
2083         pjob = print_job_find(sharename, jobid);
2084         if ( pjob && (pjob->status != LPQ_DELETING) )
2085                 *errcode = WERR_ACCESS_DENIED;
2086
2087         return (pjob == NULL );
2088 }
2089
2090 /****************************************************************************
2091  Pause a job.
2092 ****************************************************************************/
2093
2094 bool print_job_pause(struct auth_serversupplied_info *server_info, int snum,
2095                      uint32 jobid, WERROR *errcode)
2096 {
2097         const char* sharename = lp_const_servicename(snum);
2098         struct printjob *pjob;
2099         int ret = -1;
2100         struct printif *current_printif = get_printer_fns( snum );
2101
2102         pjob = print_job_find(sharename, jobid);
2103         
2104         if (!pjob || !server_info) {
2105                 DEBUG(10, ("print_job_pause: no pjob or user for jobid %u\n",
2106                         (unsigned int)jobid ));
2107                 return False;
2108         }
2109
2110         if (!pjob->spooled || pjob->sysjob == -1) {
2111                 DEBUG(10, ("print_job_pause: not spooled or bad sysjob = %d for jobid %u\n",
2112                         (int)pjob->sysjob, (unsigned int)jobid ));
2113                 return False;
2114         }
2115
2116         if (!is_owner(server_info, lp_const_servicename(snum), jobid) &&
2117             !print_access_check(server_info, snum, JOB_ACCESS_ADMINISTER)) {
2118                 DEBUG(3, ("pause denied by security descriptor\n"));
2119
2120                 /* BEGIN_ADMIN_LOG */
2121                 sys_adminlog( LOG_ERR, 
2122                         "Permission denied-- user not allowed to delete, \
2123 pause, or resume print job. User name: %s. Printer name: %s.",
2124                               uidtoname(server_info->utok.uid),
2125                               PRINTERNAME(snum) );
2126                 /* END_ADMIN_LOG */
2127
2128                 *errcode = WERR_ACCESS_DENIED;
2129                 return False;
2130         }
2131
2132         /* need to pause the spooled entry */
2133         ret = (*(current_printif->job_pause))(snum, pjob);
2134
2135         if (ret != 0) {
2136                 *errcode = WERR_INVALID_PARAM;
2137                 return False;
2138         }
2139
2140         /* force update the database */
2141         print_cache_flush(lp_const_servicename(snum));
2142
2143         /* Send a printer notify message */
2144
2145         notify_job_status(sharename, jobid, JOB_STATUS_PAUSED);
2146
2147         /* how do we tell if this succeeded? */
2148
2149         return True;
2150 }
2151
2152 /****************************************************************************
2153  Resume a job.
2154 ****************************************************************************/
2155
2156 bool print_job_resume(struct auth_serversupplied_info *server_info, int snum,
2157                       uint32 jobid, WERROR *errcode)
2158 {
2159         const char *sharename = lp_const_servicename(snum);
2160         struct printjob *pjob;
2161         int ret;
2162         struct printif *current_printif = get_printer_fns( snum );
2163
2164         pjob = print_job_find(sharename, jobid);
2165
2166         if (!pjob || !server_info) {
2167                 DEBUG(10, ("print_job_resume: no pjob or user for jobid %u\n",
2168                         (unsigned int)jobid ));
2169                 return False;
2170         }
2171
2172         if (!pjob->spooled || pjob->sysjob == -1) {
2173                 DEBUG(10, ("print_job_resume: not spooled or bad sysjob = %d for jobid %u\n",
2174                         (int)pjob->sysjob, (unsigned int)jobid ));
2175                 return False;
2176         }
2177
2178         if (!is_owner(server_info, lp_const_servicename(snum), jobid) &&
2179             !print_access_check(server_info, snum, JOB_ACCESS_ADMINISTER)) {
2180                 DEBUG(3, ("resume denied by security descriptor\n"));
2181                 *errcode = WERR_ACCESS_DENIED;
2182
2183                 /* BEGIN_ADMIN_LOG */
2184                 sys_adminlog( LOG_ERR, 
2185                          "Permission denied-- user not allowed to delete, \
2186 pause, or resume print job. User name: %s. Printer name: %s.",
2187                               uidtoname(server_info->utok.uid),
2188                               PRINTERNAME(snum) );
2189                 /* END_ADMIN_LOG */
2190                 return False;
2191         }
2192
2193         ret = (*(current_printif->job_resume))(snum, pjob);
2194
2195         if (ret != 0) {
2196                 *errcode = WERR_INVALID_PARAM;
2197                 return False;
2198         }
2199
2200         /* force update the database */
2201         print_cache_flush(lp_const_servicename(snum));
2202
2203         /* Send a printer notify message */
2204
2205         notify_job_status(sharename, jobid, JOB_STATUS_QUEUED);
2206
2207         return True;
2208 }
2209
2210 /****************************************************************************
2211  Write to a print file.
2212 ****************************************************************************/
2213
2214 ssize_t print_job_write(int snum, uint32 jobid, const char *buf, SMB_OFF_T pos, size_t size)
2215 {
2216         const char* sharename = lp_const_servicename(snum);
2217         int return_code;
2218         struct printjob *pjob;
2219
2220         pjob = print_job_find(sharename, jobid);
2221
2222         if (!pjob)
2223                 return -1;
2224         /* don't allow another process to get this info - it is meaningless */
2225         if (pjob->pid != sys_getpid())
2226                 return -1;
2227
2228         return_code = write_data_at_offset(pjob->fd, buf, size, pos);
2229
2230         if (return_code>0) {
2231                 pjob->size += size;
2232                 pjob_store(sharename, jobid, pjob);
2233         }
2234         return return_code;
2235 }
2236
2237 /****************************************************************************
2238  Get the queue status - do not update if db is out of date.
2239 ****************************************************************************/
2240
2241 static int get_queue_status(const char* sharename, print_status_struct *status)
2242 {
2243         fstring keystr;
2244         TDB_DATA data;
2245         struct tdb_print_db *pdb = get_print_db_byname(sharename);
2246         int len;
2247
2248         if (status) {
2249                 ZERO_STRUCTP(status);
2250         }
2251
2252         if (!pdb)
2253                 return 0;
2254
2255         if (status) {
2256                 fstr_sprintf(keystr, "STATUS/%s", sharename);
2257                 data = tdb_fetch(pdb->tdb, string_tdb_data(keystr));
2258                 if (data.dptr) {
2259                         if (data.dsize == sizeof(print_status_struct))
2260                                 /* this memcpy is ok since the status struct was 
2261                                    not packed before storing it in the tdb */
2262                                 memcpy(status, data.dptr, sizeof(print_status_struct));
2263                         SAFE_FREE(data.dptr);
2264                 }
2265         }
2266         len = tdb_fetch_int32(pdb->tdb, "INFO/total_jobs");
2267         release_print_db(pdb);
2268         return (len == -1 ? 0 : len);
2269 }
2270
2271 /****************************************************************************
2272  Determine the number of jobs in a queue.
2273 ****************************************************************************/
2274
2275 int print_queue_length(int snum, print_status_struct *pstatus)
2276 {
2277         const char* sharename = lp_const_servicename( snum );
2278         print_status_struct status;
2279         int len;
2280
2281         ZERO_STRUCT( status );
2282  
2283         /* make sure the database is up to date */
2284         if (print_cache_expired(lp_const_servicename(snum), True))
2285                 print_queue_update(snum, False);
2286  
2287         /* also fetch the queue status */
2288         memset(&status, 0, sizeof(status));
2289         len = get_queue_status(sharename, &status);
2290
2291         if (pstatus)
2292                 *pstatus = status;
2293
2294         return len;
2295 }
2296
2297 /***************************************************************************
2298  Allocate a jobid. Hold the lock for as short a time as possible.
2299 ***************************************************************************/
2300
2301 static bool allocate_print_jobid(struct tdb_print_db *pdb, int snum, const char *sharename, uint32 *pjobid)
2302 {
2303         int i;
2304         uint32 jobid;
2305
2306         *pjobid = (uint32)-1;
2307
2308         for (i = 0; i < 3; i++) {
2309                 /* Lock the database - only wait 20 seconds. */
2310                 if (tdb_lock_bystring_with_timeout(pdb->tdb, "INFO/nextjob", 20) == -1) {
2311                         DEBUG(0,("allocate_print_jobid: failed to lock printing database %s\n", sharename));
2312                         return False;
2313                 }
2314
2315                 if (!tdb_fetch_uint32(pdb->tdb, "INFO/nextjob", &jobid)) {
2316                         if (tdb_error(pdb->tdb) != TDB_ERR_NOEXIST) {
2317                                 DEBUG(0, ("allocate_print_jobid: failed to fetch INFO/nextjob for print queue %s\n",
2318                                         sharename));
2319                                 return False;
2320                         }
2321                         jobid = 0;
2322                 }
2323
2324                 jobid = NEXT_JOBID(jobid);
2325
2326                 if (tdb_store_int32(pdb->tdb, "INFO/nextjob", jobid)==-1) {
2327                         DEBUG(3, ("allocate_print_jobid: failed to store INFO/nextjob.\n"));
2328                         tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
2329                         return False;
2330                 }
2331
2332                 /* We've finished with the INFO/nextjob lock. */
2333                 tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
2334                                 
2335                 if (!print_job_exists(sharename, jobid))
2336                         break;
2337         }
2338
2339         if (i > 2) {
2340                 DEBUG(0, ("allocate_print_jobid: failed to allocate a print job for queue %s\n",
2341                         sharename));
2342                 /* Probably full... */
2343                 errno = ENOSPC;
2344                 return False;
2345         }
2346
2347         /* Store a dummy placeholder. */
2348         {
2349                 uint32_t tmp;
2350                 TDB_DATA dum;
2351                 dum.dptr = NULL;
2352                 dum.dsize = 0;
2353                 if (tdb_store(pdb->tdb, print_key(jobid, &tmp), dum,
2354                               TDB_INSERT) == -1) {
2355                         DEBUG(3, ("allocate_print_jobid: jobid (%d) failed to store placeholder.\n",
2356                                 jobid ));
2357                         return False;
2358                 }
2359         }
2360
2361         *pjobid = jobid;
2362         return True;
2363 }
2364
2365 /***************************************************************************
2366  Append a jobid to the 'jobs changed' list.
2367 ***************************************************************************/
2368
2369 static bool add_to_jobs_changed(struct tdb_print_db *pdb, uint32 jobid)
2370 {
2371         TDB_DATA data;
2372         uint32 store_jobid;
2373
2374         SIVAL(&store_jobid, 0, jobid);
2375         data.dptr = (uint8 *)&store_jobid;
2376         data.dsize = 4;
2377
2378         DEBUG(10,("add_to_jobs_changed: Added jobid %u\n", (unsigned int)jobid ));
2379
2380         return (tdb_append(pdb->tdb, string_tdb_data("INFO/jobs_changed"),
2381                            data) == 0);
2382 }
2383
2384 /***************************************************************************
2385  Start spooling a job - return the jobid.
2386 ***************************************************************************/
2387
2388 uint32 print_job_start(struct auth_serversupplied_info *server_info, int snum,
2389                        char *jobname, NT_DEVICEMODE *nt_devmode )
2390 {
2391         uint32 jobid;
2392         char *path;
2393         struct printjob pjob;
2394         const char *sharename = lp_const_servicename(snum);
2395         struct tdb_print_db *pdb = get_print_db_byname(sharename);
2396         int njobs;
2397
2398         errno = 0;
2399
2400         if (!pdb)
2401                 return (uint32)-1;
2402
2403         if (!print_access_check(server_info, snum, PRINTER_ACCESS_USE)) {
2404                 DEBUG(3, ("print_job_start: job start denied by security descriptor\n"));
2405                 release_print_db(pdb);
2406                 return (uint32)-1;
2407         }
2408
2409         if (!print_time_access_check(lp_servicename(snum))) {
2410                 DEBUG(3, ("print_job_start: job start denied by time check\n"));
2411                 release_print_db(pdb);
2412                 return (uint32)-1;
2413         }
2414
2415         path = lp_pathname(snum);
2416
2417         /* see if we have sufficient disk space */
2418         if (lp_minprintspace(snum)) {
2419                 uint64_t dspace, dsize;
2420                 if (sys_fsusage(path, &dspace, &dsize) == 0 &&
2421                     dspace < 2*(uint64_t)lp_minprintspace(snum)) {
2422                         DEBUG(3, ("print_job_start: disk space check failed.\n"));
2423                         release_print_db(pdb);
2424                         errno = ENOSPC;
2425                         return (uint32)-1;
2426                 }
2427         }
2428
2429         /* for autoloaded printers, check that the printcap entry still exists */
2430         if (lp_autoloaded(snum) && !pcap_printername_ok(lp_const_servicename(snum))) {
2431                 DEBUG(3, ("print_job_start: printer name %s check failed.\n", lp_const_servicename(snum) ));
2432                 release_print_db(pdb);
2433                 errno = ENOENT;
2434                 return (uint32)-1;
2435         }
2436
2437         /* Insure the maximum queue size is not violated */
2438         if ((njobs = print_queue_length(snum,NULL)) > lp_maxprintjobs(snum)) {
2439                 DEBUG(3, ("print_job_start: Queue %s number of jobs (%d) larger than max printjobs per queue (%d).\n",
2440                         sharename, njobs, lp_maxprintjobs(snum) ));
2441                 release_print_db(pdb);
2442                 errno = ENOSPC;
2443                 return (uint32)-1;
2444         }
2445
2446         DEBUG(10,("print_job_start: Queue %s number of jobs (%d), max printjobs = %d\n",
2447                 sharename, njobs, lp_maxprintjobs(snum) ));
2448
2449         if (!allocate_print_jobid(pdb, snum, sharename, &jobid))
2450                 goto fail;
2451
2452         /* create the database entry */
2453         
2454         ZERO_STRUCT(pjob);
2455         
2456         pjob.pid = sys_getpid();
2457         pjob.sysjob = -1;
2458         pjob.fd = -1;
2459         pjob.starttime = time(NULL);
2460         pjob.status = LPQ_SPOOLING;
2461         pjob.size = 0;
2462         pjob.spooled = False;
2463         pjob.smbjob = True;
2464         pjob.nt_devmode = nt_devmode;
2465         
2466         fstrcpy(pjob.jobname, jobname);
2467
2468         fstrcpy(pjob.user, lp_printjob_username(snum));
2469         standard_sub_advanced(sharename, server_info->sanitized_username,
2470                               path, server_info->utok.gid, 
2471                               server_info->sanitized_username,
2472                               pdb_get_domain(server_info->sam_account),
2473                               pjob.user, sizeof(pjob.user)-1);
2474         /* ensure NULL termination */
2475         pjob.user[sizeof(pjob.user)-1] = '\0';
2476
2477         fstrcpy(pjob.queuename, lp_const_servicename(snum));
2478
2479         /* we have a job entry - now create the spool file */
2480         slprintf(pjob.filename, sizeof(pjob.filename)-1, "%s/%s%.8u.XXXXXX", 
2481                  path, PRINT_SPOOL_PREFIX, (unsigned int)jobid);
2482         pjob.fd = smb_mkstemp(pjob.filename);
2483
2484         if (pjob.fd == -1) {
2485                 if (errno == EACCES) {
2486                         /* Common setup error, force a report. */
2487                         DEBUG(0, ("print_job_start: insufficient permissions \
2488 to open spool file %s.\n", pjob.filename));
2489                 } else {
2490                         /* Normal case, report at level 3 and above. */
2491                         DEBUG(3, ("print_job_start: can't open spool file %s,\n", pjob.filename));
2492                         DEBUGADD(3, ("errno = %d (%s).\n", errno, strerror(errno)));
2493                 }
2494                 goto fail;
2495         }
2496
2497         pjob_store(sharename, jobid, &pjob);
2498
2499         /* Update the 'jobs changed' entry used by print_queue_status. */
2500         add_to_jobs_changed(pdb, jobid);
2501
2502         /* Ensure we keep a rough count of the number of total jobs... */
2503         tdb_change_int32_atomic(pdb->tdb, "INFO/total_jobs", &njobs, 1);
2504
2505         release_print_db(pdb);
2506
2507         return jobid;
2508
2509  fail:
2510         if (jobid != -1)
2511                 pjob_delete(sharename, jobid);
2512
2513         release_print_db(pdb);
2514
2515         DEBUG(3, ("print_job_start: returning fail. Error = %s\n", strerror(errno) ));
2516         return (uint32)-1;
2517 }
2518
2519 /****************************************************************************
2520  Update the number of pages spooled to jobid
2521 ****************************************************************************/
2522
2523 void print_job_endpage(int snum, uint32 jobid)
2524 {
2525         const char* sharename = lp_const_servicename(snum);
2526         struct printjob *pjob;
2527
2528         pjob = print_job_find(sharename, jobid);
2529         if (!pjob)
2530                 return;
2531         /* don't allow another process to get this info - it is meaningless */
2532         if (pjob->pid != sys_getpid())
2533                 return;
2534
2535         pjob->page_count++;
2536         pjob_store(sharename, jobid, pjob);
2537 }
2538
2539 /****************************************************************************
2540  Print a file - called on closing the file. This spools the job.
2541  If normal close is false then we're tearing down the jobs - treat as an
2542  error.
2543 ****************************************************************************/
2544
2545 bool print_job_end(int snum, uint32 jobid, enum file_close_type close_type)
2546 {
2547         const char* sharename = lp_const_servicename(snum);
2548         struct printjob *pjob;
2549         int ret;
2550         SMB_STRUCT_STAT sbuf;
2551         struct printif *current_printif = get_printer_fns( snum );
2552
2553         pjob = print_job_find(sharename, jobid);
2554
2555         if (!pjob)
2556                 return False;
2557
2558         if (pjob->spooled || pjob->pid != sys_getpid())
2559                 return False;
2560
2561         if ((close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) &&
2562                                 (sys_fstat(pjob->fd, &sbuf) == 0)) {
2563                 pjob->size = sbuf.st_size;
2564                 close(pjob->fd);
2565                 pjob->fd = -1;
2566         } else {
2567
2568                 /* 
2569                  * Not a normal close or we couldn't stat the job file,
2570                  * so something has gone wrong. Cleanup.
2571                  */
2572                 close(pjob->fd);
2573                 pjob->fd = -1;
2574                 DEBUG(3,("print_job_end: failed to stat file for jobid %d\n", jobid ));
2575                 goto fail;
2576         }
2577
2578         /* Technically, this is not quite right. If the printer has a separator
2579          * page turned on, the NT spooler prints the separator page even if the
2580          * print job is 0 bytes. 010215 JRR */
2581         if (pjob->size == 0 || pjob->status == LPQ_DELETING) {
2582                 /* don't bother spooling empty files or something being deleted. */
2583                 DEBUG(5,("print_job_end: canceling spool of %s (%s)\n",
2584                         pjob->filename, pjob->size ? "deleted" : "zero length" ));
2585                 unlink(pjob->filename);
2586                 pjob_delete(sharename, jobid);
2587                 return True;
2588         }
2589
2590         pjob->smbjob = jobid;
2591
2592         ret = (*(current_printif->job_submit))(snum, pjob);
2593
2594         if (ret)
2595                 goto fail;
2596
2597         /* The print job has been successfully handed over to the back-end */
2598         
2599         pjob->spooled = True;
2600         pjob->status = LPQ_QUEUED;
2601         pjob_store(sharename, jobid, pjob);
2602         
2603         /* make sure the database is up to date */
2604         if (print_cache_expired(lp_const_servicename(snum), True))
2605                 print_queue_update(snum, False);
2606         
2607         return True;
2608
2609 fail:
2610
2611         /* The print job was not successfully started. Cleanup */
2612         /* Still need to add proper error return propagation! 010122:JRR */
2613         unlink(pjob->filename);
2614         pjob_delete(sharename, jobid);
2615         return False;
2616 }
2617
2618 /****************************************************************************
2619  Get a snapshot of jobs in the system without traversing.
2620 ****************************************************************************/
2621
2622 static bool get_stored_queue_info(struct tdb_print_db *pdb, int snum, int *pcount, print_queue_struct **ppqueue)
2623 {
2624         TDB_DATA data, cgdata;
2625         print_queue_struct *queue = NULL;
2626         uint32 qcount = 0;
2627         uint32 extra_count = 0;
2628         int total_count = 0;
2629         size_t len = 0;
2630         uint32 i;
2631         int max_reported_jobs = lp_max_reported_jobs(snum);
2632         bool ret = False;
2633         const char* sharename = lp_servicename(snum);
2634
2635         /* make sure the database is up to date */
2636         if (print_cache_expired(lp_const_servicename(snum), True))
2637                 print_queue_update(snum, False);
2638  
2639         *pcount = 0;
2640         *ppqueue = NULL;
2641
2642         ZERO_STRUCT(data);
2643         ZERO_STRUCT(cgdata);
2644
2645         /* Get the stored queue data. */
2646         data = tdb_fetch(pdb->tdb, string_tdb_data("INFO/linear_queue_array"));
2647         
2648         if (data.dptr && data.dsize >= sizeof(qcount))
2649                 len += tdb_unpack(data.dptr + len, data.dsize - len, "d", &qcount);
2650                 
2651         /* Get the changed jobs list. */
2652         cgdata = tdb_fetch(pdb->tdb, string_tdb_data("INFO/jobs_changed"));
2653         if (cgdata.dptr != NULL && (cgdata.dsize % 4 == 0))
2654                 extra_count = cgdata.dsize/4;
2655
2656         DEBUG(5,("get_stored_queue_info: qcount = %u, extra_count = %u\n", (unsigned int)qcount, (unsigned int)extra_count));
2657
2658         /* Allocate the queue size. */
2659         if (qcount == 0 && extra_count == 0)
2660                 goto out;
2661
2662         if ((queue = SMB_MALLOC_ARRAY(print_queue_struct, qcount + extra_count)) == NULL)
2663                 goto out;
2664
2665         /* Retrieve the linearised queue data. */
2666
2667         for( i  = 0; i < qcount; i++) {
2668                 uint32 qjob, qsize, qpage_count, qstatus, qpriority, qtime;
2669                 len += tdb_unpack(data.dptr + len, data.dsize - len, "ddddddff",
2670                                 &qjob,
2671                                 &qsize,
2672                                 &qpage_count,
2673                                 &qstatus,
2674                                 &qpriority,
2675                                 &qtime,
2676                                 queue[i].fs_user,
2677                                 queue[i].fs_file);
2678                 queue[i].job = qjob;
2679                 queue[i].size = qsize;
2680                 queue[i].page_count = qpage_count;
2681                 queue[i].status = qstatus;
2682                 queue[i].priority = qpriority;
2683                 queue[i].time = qtime;
2684         }
2685
2686         total_count = qcount;
2687
2688         /* Add in the changed jobids. */
2689         for( i  = 0; i < extra_count; i++) {
2690                 uint32 jobid;
2691                 struct printjob *pjob;
2692
2693                 jobid = IVAL(cgdata.dptr, i*4);
2694                 DEBUG(5,("get_stored_queue_info: changed job = %u\n", (unsigned int)jobid));
2695                 pjob = print_job_find(lp_const_servicename(snum), jobid);
2696                 if (!pjob) {
2697                         DEBUG(5,("get_stored_queue_info: failed to find changed job = %u\n", (unsigned int)jobid));
2698                         remove_from_jobs_changed(sharename, jobid);
2699                         continue;
2700                 }
2701
2702                 queue[total_count].job = jobid;
2703                 queue[total_count].size = pjob->size;
2704                 queue[total_count].page_count = pjob->page_count;
2705                 queue[total_count].status = pjob->status;
2706                 queue[total_count].priority = 1;
2707                 queue[total_count].time = pjob->starttime;
2708                 fstrcpy(queue[total_count].fs_user, pjob->user);
2709                 fstrcpy(queue[total_count].fs_file, pjob->jobname);
2710                 total_count++;
2711         }
2712
2713         /* Sort the queue by submission time otherwise they are displayed
2714            in hash order. */
2715
2716         qsort(queue, total_count, sizeof(print_queue_struct), QSORT_CAST(printjob_comp));
2717
2718         DEBUG(5,("get_stored_queue_info: total_count = %u\n", (unsigned int)total_count));
2719
2720         if (max_reported_jobs && total_count > max_reported_jobs)
2721                 total_count = max_reported_jobs;
2722
2723         *ppqueue = queue;
2724         *pcount = total_count;
2725
2726         ret = True;
2727
2728   out:
2729
2730         SAFE_FREE(data.dptr);
2731         SAFE_FREE(cgdata.dptr);
2732         return ret;
2733 }
2734
2735 /****************************************************************************
2736  Get a printer queue listing.
2737  set queue = NULL and status = NULL if you just want to update the cache
2738 ****************************************************************************/
2739
2740 int print_queue_status(int snum, 
2741                        print_queue_struct **ppqueue,
2742                        print_status_struct *status)
2743 {
2744         fstring keystr;
2745         TDB_DATA data, key;
2746         const char *sharename;
2747         struct tdb_print_db *pdb;
2748         int count = 0;
2749
2750         /* make sure the database is up to date */
2751
2752         if (print_cache_expired(lp_const_servicename(snum), True))
2753                 print_queue_update(snum, False);
2754
2755         /* return if we are done */
2756         if ( !ppqueue || !status )
2757                 return 0;
2758
2759         *ppqueue = NULL;
2760         sharename = lp_const_servicename(snum);
2761         pdb = get_print_db_byname(sharename);
2762
2763         if (!pdb)
2764                 return 0;
2765
2766         /*
2767          * Fetch the queue status.  We must do this first, as there may
2768          * be no jobs in the queue.
2769          */
2770
2771         ZERO_STRUCTP(status);
2772         slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", sharename);
2773         key = string_tdb_data(keystr);
2774
2775         data = tdb_fetch(pdb->tdb, key);
2776         if (data.dptr) {
2777                 if (data.dsize == sizeof(*status)) {
2778                         /* this memcpy is ok since the status struct was 
2779                            not packed before storing it in the tdb */
2780                         memcpy(status, data.dptr, sizeof(*status));
2781                 }
2782                 SAFE_FREE(data.dptr);
2783         }
2784
2785         /*
2786          * Now, fetch the print queue information.  We first count the number
2787          * of entries, and then only retrieve the queue if necessary.
2788          */
2789
2790         if (!get_stored_queue_info(pdb, snum, &count, ppqueue)) {
2791                 release_print_db(pdb);
2792                 return 0;
2793         }
2794
2795         release_print_db(pdb);
2796         return count;
2797 }
2798
2799 /****************************************************************************
2800  Pause a queue.
2801 ****************************************************************************/
2802
2803 bool print_queue_pause(struct auth_serversupplied_info *server_info, int snum,
2804                        WERROR *errcode)
2805 {
2806         int ret;
2807         struct printif *current_printif = get_printer_fns( snum );
2808         
2809         if (!print_access_check(server_info, snum,
2810                                 PRINTER_ACCESS_ADMINISTER)) {
2811                 *errcode = WERR_ACCESS_DENIED;
2812                 return False;
2813         }
2814         
2815
2816         become_root();
2817                 
2818         ret = (*(current_printif->queue_pause))(snum);
2819
2820         unbecome_root();
2821                 
2822         if (ret != 0) {
2823                 *errcode = WERR_INVALID_PARAM;
2824                 return False;
2825         }
2826
2827         /* force update the database */
2828         print_cache_flush(lp_const_servicename(snum));
2829
2830         /* Send a printer notify message */
2831
2832         notify_printer_status(snum, PRINTER_STATUS_PAUSED);
2833
2834         return True;
2835 }
2836
2837 /****************************************************************************
2838  Resume a queue.
2839 ****************************************************************************/
2840
2841 bool print_queue_resume(struct auth_serversupplied_info *server_info, int snum,
2842                         WERROR *errcode)
2843 {
2844         int ret;
2845         struct printif *current_printif = get_printer_fns( snum );
2846
2847         if (!print_access_check(server_info, snum,
2848                                 PRINTER_ACCESS_ADMINISTER)) {
2849                 *errcode = WERR_ACCESS_DENIED;
2850                 return False;
2851         }
2852         
2853         become_root();
2854                 
2855         ret = (*(current_printif->queue_resume))(snum);
2856
2857         unbecome_root();
2858                 
2859         if (ret != 0) {
2860                 *errcode = WERR_INVALID_PARAM;
2861                 return False;
2862         }
2863
2864         /* make sure the database is up to date */
2865         if (print_cache_expired(lp_const_servicename(snum), True))
2866                 print_queue_update(snum, True);
2867
2868         /* Send a printer notify message */
2869
2870         notify_printer_status(snum, PRINTER_STATUS_OK);
2871
2872         return True;
2873 }
2874
2875 /****************************************************************************
2876  Purge a queue - implemented by deleting all jobs that we can delete.
2877 ****************************************************************************/
2878
2879 bool print_queue_purge(struct auth_serversupplied_info *server_info, int snum,
2880                        WERROR *errcode)
2881 {
2882         print_queue_struct *queue;
2883         print_status_struct status;
2884         int njobs, i;
2885         bool can_job_admin;
2886
2887         /* Force and update so the count is accurate (i.e. not a cached count) */
2888         print_queue_update(snum, True);
2889         
2890         can_job_admin = print_access_check(server_info, snum,
2891                                            JOB_ACCESS_ADMINISTER);
2892         njobs = print_queue_status(snum, &queue, &status);
2893         
2894         if ( can_job_admin )
2895                 become_root();
2896
2897         for (i=0;i<njobs;i++) {
2898                 bool owner = is_owner(server_info, lp_const_servicename(snum),
2899                                       queue[i].job);
2900
2901                 if (owner || can_job_admin) {
2902                         print_job_delete1(snum, queue[i].job);
2903                 }
2904         }
2905         
2906         if ( can_job_admin )
2907                 unbecome_root();
2908
2909         /* update the cache */
2910         print_queue_update( snum, True );
2911
2912         SAFE_FREE(queue);
2913
2914         return True;
2915 }