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