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