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 25extern struct current_user current_user; 26extern userdom_struct current_user_info; 27 28/* Current printer interface */ 29static 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 45static TDB_CONTEXT *rap_tdb; 46static uint16 next_rap_jobid; 47struct 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 57uint16 pjobid_to_rap(const char* sharename, uint32 jobid) 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 103bool rap_to_pjobid(uint16 rap_jobid, fstring sharename, uint32 *pjobid) 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 136static 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 174static 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 180bool print_backend_init(struct messaging_context *msg_ctx) 181{ 182 const char *sversion = "INFO/version"; 183 int services = lp_numservices(); 184 int snum; 185 186 unlink(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 222void printing_end(void) 223{ 224 close_all_print_db(); /* Don't leave any open. */ 225} 226 227/**************************************************************************** 228 Retrieve the set of printing functions for a given service. This allows 229 us to set the printer function table based on the value of the 'printing' 230 service parameter. 231 232 Use the generic interface as the default and only use cups interface only 233 when asked for (and only when supported) 234****************************************************************************/ 235 236static struct printif *get_printer_fns_from_type( enum printing_types type ) 237{ 238 struct printif *printer_fns = &generic_printif; 239 240#ifdef HAVE_CUPS 241 if ( type == PRINT_CUPS ) { 242 printer_fns = &cups_printif; 243 } 244#endif /* HAVE_CUPS */ 245 246#ifdef HAVE_IPRINT 247 if ( type == PRINT_IPRINT ) { 248 printer_fns = &iprint_printif; 249 } 250#endif /* HAVE_IPRINT */ 251 252 printer_fns->type = type; 253 254 return printer_fns; 255} 256 257static struct printif *get_printer_fns( int snum ) 258{ 259 return get_printer_fns_from_type( (enum printing_types)lp_printing(snum) ); 260} 261 262 263/**************************************************************************** 264 Useful function to generate a tdb key. 265****************************************************************************/ 266 267static TDB_DATA print_key(uint32 jobid, uint32 *tmp) 268{ 269 TDB_DATA ret; 270 271 SIVAL(tmp, 0, jobid); 272 ret.dptr = (uint8 *)tmp; 273 ret.dsize = sizeof(*tmp); 274 return ret; 275} 276 277/*********************************************************************** 278 unpack a pjob from a tdb buffer 279***********************************************************************/ 280 281int unpack_pjob( uint8 *buf, int buflen, struct printjob *pjob ) 282{ 283 int len = 0; 284 int used; 285 uint32 pjpid, pjsysjob, pjfd, pjstarttime, pjstatus; 286 uint32 pjsize, pjpage_count, pjspooled, pjsmbjob; 287 288 if ( !buf || !pjob ) 289 return -1; 290 291 len += tdb_unpack(buf+len, buflen-len, "dddddddddffff", 292 &pjpid, 293 &pjsysjob, 294 &pjfd, 295 &pjstarttime, 296 &pjstatus, 297 &pjsize, 298 &pjpage_count, 299 &pjspooled, 300 &pjsmbjob, 301 pjob->filename, 302 pjob->jobname, 303 pjob->user, 304 pjob->queuename); 305 306 if ( len == -1 ) 307 return -1; 308 309 if ( (used = unpack_devicemode(&pjob->nt_devmode, buf+len, buflen-len)) == -1 ) 310 return -1; 311 312 len += used; 313 314 pjob->pid = pjpid; 315 pjob->sysjob = pjsysjob; 316 pjob->fd = pjfd; 317 pjob->starttime = pjstarttime; 318 pjob->status = pjstatus; 319 pjob->size = pjsize; 320 pjob->page_count = pjpage_count; 321 pjob->spooled = pjspooled; 322 pjob->smbjob = pjsmbjob; 323 324 return len; 325 326} 327 328/**************************************************************************** 329 Useful function to find a print job in the database. 330****************************************************************************/ 331 332static struct printjob *print_job_find(const char *sharename, uint32 jobid) 333{ 334 static struct printjob pjob; 335 uint32_t tmp; 336 TDB_DATA ret; 337 struct tdb_print_db *pdb = get_print_db_byname(sharename); 338 339 DEBUG(10,("print_job_find: looking up job %u for share %s\n", 340 (unsigned int)jobid, sharename )); 341 342 if (!pdb) { 343 return NULL; 344 } 345 346 ret = tdb_fetch(pdb->tdb, print_key(jobid, &tmp)); 347 release_print_db(pdb); 348 349 if (!ret.dptr) { 350 DEBUG(10,("print_job_find: failed to find jobid %u.\n", (unsigned int)jobid )); 351 return NULL; 352 } 353 354 if ( pjob.nt_devmode ) { 355 free_nt_devicemode( &pjob.nt_devmode ); 356 } 357 358 ZERO_STRUCT( pjob ); 359 360 if ( unpack_pjob( ret.dptr, ret.dsize, &pjob ) == -1 ) { 361 DEBUG(10,("print_job_find: failed to unpack jobid %u.\n", (unsigned int)jobid )); 362 SAFE_FREE(ret.dptr); 363 return NULL; 364 } 365 366 SAFE_FREE(ret.dptr); 367 368 DEBUG(10,("print_job_find: returning system job %d for jobid %u.\n", 369 (int)pjob.sysjob, (unsigned int)jobid )); 370 371 return &pjob; 372} 373 374/* Convert a unix jobid to a smb jobid */ 375 376struct unixjob_traverse_state { 377 int sysjob; 378 uint32 sysjob_to_jobid_value; 379}; 380 381static int unixjob_traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA key, 382 TDB_DATA data, void *private_data) 383{ 384 struct printjob *pjob; 385 struct unixjob_traverse_state *state = 386 (struct unixjob_traverse_state *)private_data; 387 388 if (!data.dptr || data.dsize == 0) 389 return 0; 390 391 pjob = (struct printjob *)data.dptr; 392 if (key.dsize != sizeof(uint32)) 393 return 0; 394 395 if (state->sysjob == pjob->sysjob) { 396 uint32 jobid = IVAL(key.dptr,0); 397 398 state->sysjob_to_jobid_value = jobid; 399 return 1; 400 } 401 402 return 0; 403} 404 405/**************************************************************************** 406 This is a *horribly expensive call as we have to iterate through all the 407 current printer tdb's. Don't do this often ! JRA. 408****************************************************************************/ 409 410uint32 sysjob_to_jobid(int unix_jobid) 411{ 412 int services = lp_numservices(); 413 int snum; 414 struct unixjob_traverse_state state; 415 416 state.sysjob = unix_jobid; 417 state.sysjob_to_jobid_value = (uint32)-1; 418 419 for (snum = 0; snum < services; snum++) { 420 struct tdb_print_db *pdb; 421 if (!lp_print_ok(snum)) 422 continue; 423 pdb = get_print_db_byname(lp_const_servicename(snum)); 424 if (!pdb) { 425 continue; 426 } 427 tdb_traverse(pdb->tdb, unixjob_traverse_fn, &state); 428 release_print_db(pdb); 429 if (state.sysjob_to_jobid_value != (uint32)-1) 430 return state.sysjob_to_jobid_value; 431 } 432 return (uint32)-1; 433} 434 435/**************************************************************************** 436 Send notifications based on what has changed after a pjob_store. 437****************************************************************************/ 438 439static 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 460static uint32 map_to_spoolss_status(uint32 lpq_status) 461{ 462 int i = 0; 463 464 while (lpq_to_spoolss_status_map[i].lpq_status != -1) { 465 if (lpq_to_spoolss_status_map[i].lpq_status == lpq_status) 466 return lpq_to_spoolss_status_map[i].spoolss_status; 467 i++; 468 } 469 470 return 0; 471} 472 473static void pjob_store_notify(const char* sharename, uint32 jobid, struct printjob *old_data, 474 struct printjob *new_data) 475{ 476 bool new_job = False; 477 478 if (!old_data) 479 new_job = True; 480 481 /* Job attributes that can't be changed. We only send 482 notification for these on a new job. */ 483 484 /* ACHTUNG! Due to a bug in Samba's spoolss parsing of the 485 NOTIFY_INFO_DATA buffer, we *have* to send the job submission 486 time first or else we'll end up with potential alignment 487 errors. I don't think the systemtime should be spooled as 488 a string, but this gets us around that error. 489 --jerry (i'll feel dirty for this) */ 490 491 if (new_job) { 492 notify_job_submitted(sharename, jobid, new_data->starttime); 493 notify_job_username(sharename, jobid, new_data->user); 494 } 495 496 if (new_job || !strequal(old_data->jobname, new_data->jobname)) 497 notify_job_name(sharename, jobid, new_data->jobname); 498 499 /* Job attributes of a new job or attributes that can be 500 modified. */ 501 502 if (new_job || !strequal(old_data->jobname, new_data->jobname)) 503 notify_job_name(sharename, jobid, new_data->jobname); 504 505 if (new_job || old_data->status != new_data->status) 506 notify_job_status(sharename, jobid, map_to_spoolss_status(new_data->status)); 507 508 if (new_job || old_data->size != new_data->size) 509 notify_job_total_bytes(sharename, jobid, new_data->size); 510 511 if (new_job || old_data->page_count != new_data->page_count) 512 notify_job_total_pages(sharename, jobid, new_data->page_count); 513} 514 515/**************************************************************************** 516 Store a job structure back to the database. 517****************************************************************************/ 518 519static bool pjob_store(const char* sharename, uint32 jobid, struct printjob *pjob) 520{ 521 uint32_t tmp; 522 TDB_DATA old_data, new_data; 523 bool ret = False; 524 struct tdb_print_db *pdb = get_print_db_byname(sharename); 525 uint8 *buf = NULL; 526 int len, newlen, buflen; 527 528 529 if (!pdb) 530 return False; 531 532 /* Get old data */ 533 534 old_data = tdb_fetch(pdb->tdb, print_key(jobid, &tmp)); 535 536 /* Doh! Now we have to pack/unpack data since the NT_DEVICEMODE was added */ 537 538 newlen = 0; 539 540 do { 541 len = 0; 542 buflen = newlen; 543 len += tdb_pack(buf+len, buflen-len, "dddddddddffff", 544 (uint32)pjob->pid, 545 (uint32)pjob->sysjob, 546 (uint32)pjob->fd, 547 (uint32)pjob->starttime, 548 (uint32)pjob->status, 549 (uint32)pjob->size, 550 (uint32)pjob->page_count, 551 (uint32)pjob->spooled, 552 (uint32)pjob->smbjob, 553 pjob->filename, 554 pjob->jobname, 555 pjob->user, 556 pjob->queuename); 557 558 len += pack_devicemode(pjob->nt_devmode, buf+len, buflen-len); 559 560 if (buflen != len) { 561 buf = (uint8 *)SMB_REALLOC(buf, len); 562 if (!buf) { 563 DEBUG(0,("pjob_store: failed to enlarge buffer!\n")); 564 goto done; 565 } 566 newlen = len; 567 } 568 } while ( buflen != len ); 569 570 571 /* Store new data */ 572 573 new_data.dptr = buf; 574 new_data.dsize = len; 575 ret = (tdb_store(pdb->tdb, print_key(jobid, &tmp), new_data, 576 TDB_REPLACE) == 0); 577 578 release_print_db(pdb); 579 580 /* Send notify updates for what has changed */ 581 582 if ( ret ) { 583 struct printjob old_pjob; 584 585 if ( old_data.dsize ) 586 { 587 if ( unpack_pjob( old_data.dptr, old_data.dsize, &old_pjob ) != -1 ) 588 { 589 pjob_store_notify( sharename, jobid, &old_pjob , pjob ); 590 free_nt_devicemode( &old_pjob.nt_devmode ); 591 } 592 } 593 else { 594 /* new job */ 595 pjob_store_notify( sharename, jobid, NULL, pjob ); 596 } 597 } 598 599done: 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 610void pjob_delete(const char* sharename, uint32 jobid) 611{ 612 uint32_t tmp; 613 struct printjob *pjob; 614 uint32 job_status = 0; 615 struct tdb_print_db *pdb; 616 617 pdb = get_print_db_byname( sharename ); 618 619 if (!pdb) 620 return; 621 622 pjob = print_job_find( sharename, jobid ); 623 624 if (!pjob) { 625 DEBUG(5, ("pjob_delete: we were asked to delete nonexistent job %u\n", 626 (unsigned int)jobid)); 627 release_print_db(pdb); 628 return; 629 } 630 631 /* We must cycle through JOB_STATUS_DELETING and 632 JOB_STATUS_DELETED for the port monitor to delete the job 633 properly. */ 634 635 job_status = JOB_STATUS_DELETING|JOB_STATUS_DELETED; 636 notify_job_status(sharename, jobid, job_status); 637 638 /* Remove from printing.tdb */ 639 640 tdb_delete(pdb->tdb, print_key(jobid, &tmp)); 641 remove_from_jobs_changed(sharename, jobid); 642 release_print_db( pdb ); 643 rap_jobid_delete(sharename, jobid); 644} 645 646/**************************************************************************** 647 List a unix job in the print database. 648****************************************************************************/ 649 650static void print_unix_job(const char *sharename, print_queue_struct *q, uint32 jobid) 651{ 652 struct printjob pj, *old_pj; 653 654 if (jobid == (uint32)-1) 655 jobid = q->job + UNIX_JOB_START; 656 657 /* Preserve the timestamp on an existing unix print job */ 658 659 old_pj = print_job_find(sharename, jobid); 660 661 ZERO_STRUCT(pj); 662 663 pj.pid = (pid_t)-1; 664 pj.sysjob = q->job; 665 pj.fd = -1; 666 pj.starttime = old_pj ? old_pj->starttime : q->time; 667 pj.status = q->status; 668 pj.size = q->size; 669 pj.spooled = True; 670 fstrcpy(pj.filename, old_pj ? old_pj->filename : ""); 671 if (jobid < UNIX_JOB_START) { 672 pj.smbjob = True; 673 fstrcpy(pj.jobname, old_pj ? old_pj->jobname : "Remote Downlevel Document"); 674 } else { 675 pj.smbjob = False; 676 fstrcpy(pj.jobname, old_pj ? old_pj->jobname : q->fs_file); 677 } 678 fstrcpy(pj.user, old_pj ? old_pj->user : q->fs_user); 679 fstrcpy(pj.queuename, old_pj ? old_pj->queuename : sharename ); 680 681 pjob_store(sharename, jobid, &pj); 682} 683 684 685struct traverse_struct { 686 print_queue_struct *queue; 687 int qcount, snum, maxcount, total_jobs; 688 const char *sharename; 689 time_t lpq_time; 690 const char *lprm_command; 691 struct printif *print_if; 692}; 693 694/**************************************************************************** 695 Utility fn to delete any jobs that are no longer active. 696****************************************************************************/ 697 698static int traverse_fn_delete(TDB_CONTEXT *t, TDB_DATA key, TDB_DATA data, void *state) 699{ 700 struct traverse_struct *ts = (struct traverse_struct *)state; 701 struct printjob pjob; 702 uint32 jobid; 703 int i = 0; 704 705 if ( key.dsize != sizeof(jobid) ) 706 return 0; 707 708 jobid = IVAL(key.dptr, 0); 709 if ( unpack_pjob( data.dptr, data.dsize, &pjob ) == -1 ) 710 return 0; 711 free_nt_devicemode( &pjob.nt_devmode ); 712 713 714 if (!pjob.smbjob) { 715 /* remove a unix job if it isn't in the system queue any more */ 716 717 for (i=0;i<ts->qcount;i++) { 718 uint32 u_jobid = (ts->queue[i].job + UNIX_JOB_START); 719 if (jobid == u_jobid) 720 break; 721 } 722 if (i == ts->qcount) { 723 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !smbjob\n", 724 (unsigned int)jobid )); 725 pjob_delete(ts->sharename, jobid); 726 return 0; 727 } 728 729 /* need to continue the the bottom of the function to 730 save the correct attributes */ 731 } 732 733 /* maybe it hasn't been spooled yet */ 734 if (!pjob.spooled) { 735 /* if a job is not spooled and the process doesn't 736 exist then kill it. This cleans up after smbd 737 deaths */ 738 if (!process_exists_by_pid(pjob.pid)) { 739 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !process_exists (%u)\n", 740 (unsigned int)jobid, (unsigned int)pjob.pid )); 741 pjob_delete(ts->sharename, jobid); 742 } else 743 ts->total_jobs++; 744 return 0; 745 } 746 747 /* this check only makes sense for jobs submitted from Windows clients */ 748 749 if ( pjob.smbjob ) { 750 for (i=0;i<ts->qcount;i++) { 751 uint32 curr_jobid; 752 753 if ( pjob.status == LPQ_DELETED ) 754 continue; 755 756 curr_jobid = print_parse_jobid(ts->queue[i].fs_file); 757 758 if (jobid == curr_jobid) { 759 760 /* try to clean up any jobs that need to be deleted */ 761 762 if ( pjob.status == LPQ_DELETING ) { 763 int result; 764 765 result = (*(ts->print_if->job_delete))( 766 ts->sharename, ts->lprm_command, &pjob ); 767 768 if ( result != 0 ) { 769 /* if we can't delete, then reset the job status */ 770 pjob.status = LPQ_QUEUED; 771 pjob_store(ts->sharename, jobid, &pjob); 772 } 773 else { 774 /* if we deleted the job, the remove the tdb record */ 775 pjob_delete(ts->sharename, jobid); 776 pjob.status = LPQ_DELETED; 777 } 778 779 } 780 781 break; 782 } 783 } 784 } 785 786 /* The job isn't in the system queue - we have to assume it has 787 completed, so delete the database entry. */ 788 789 if (i == ts->qcount) { 790 791 /* A race can occur between the time a job is spooled and 792 when it appears in the lpq output. This happens when 793 the job is added to printing.tdb when another smbd 794 running print_queue_update() has completed a lpq and 795 is currently traversing the printing tdb and deleting jobs. 796 Don't delete the job if it was submitted after the lpq_time. */ 797 798 if (pjob.starttime < ts->lpq_time) { 799 DEBUG(10,("traverse_fn_delete: pjob %u deleted due to pjob.starttime (%u) < ts->lpq_time (%u)\n", 800 (unsigned int)jobid, 801 (unsigned int)pjob.starttime, 802 (unsigned int)ts->lpq_time )); 803 pjob_delete(ts->sharename, jobid); 804 } else 805 ts->total_jobs++; 806 return 0; 807 } 808 809 /* Save the pjob attributes we will store. 810 FIXME!!! This is the only place where queue->job 811 represents the SMB jobid --jerry */ 812 813 ts->queue[i].job = jobid; 814 ts->queue[i].size = pjob.size; 815 ts->queue[i].page_count = pjob.page_count; 816 ts->queue[i].status = pjob.status; 817 ts->queue[i].priority = 1; 818 ts->queue[i].time = pjob.starttime; 819 fstrcpy(ts->queue[i].fs_user, pjob.user); 820 fstrcpy(ts->queue[i].fs_file, pjob.jobname); 821 822 ts->total_jobs++; 823 824 return 0; 825} 826 827/**************************************************************************** 828 Check if the print queue has been updated recently enough. 829****************************************************************************/ 830 831static void print_cache_flush(const char *sharename) 832{ 833 fstring key; 834 struct tdb_print_db *pdb = get_print_db_byname(sharename); 835 836 if (!pdb) 837 return; 838 slprintf(key, sizeof(key)-1, "CACHE/%s", sharename); 839 tdb_store_int32(pdb->tdb, key, -1); 840 release_print_db(pdb); 841} 842 843/**************************************************************************** 844 Check if someone already thinks they are doing the update. 845****************************************************************************/ 846 847static pid_t get_updating_pid(const char *sharename) 848{ 849 fstring keystr; 850 TDB_DATA data, key; 851 pid_t updating_pid; 852 struct tdb_print_db *pdb = get_print_db_byname(sharename); 853 854 if (!pdb) 855 return (pid_t)-1; 856 slprintf(keystr, sizeof(keystr)-1, "UPDATING/%s", sharename); 857 key = string_tdb_data(keystr); 858 859 data = tdb_fetch(pdb->tdb, key); 860 release_print_db(pdb); 861 if (!data.dptr || data.dsize != sizeof(pid_t)) { 862 SAFE_FREE(data.dptr); 863 return (pid_t)-1; 864 } 865 866 updating_pid = IVAL(data.dptr, 0); 867 SAFE_FREE(data.dptr); 868 869 if (process_exists_by_pid(updating_pid)) 870 return updating_pid; 871 872 return (pid_t)-1; 873} 874 875/**************************************************************************** 876 Set the fact that we're doing the update, or have finished doing the update 877 in the tdb. 878****************************************************************************/ 879 880static void set_updating_pid(const fstring sharename, bool updating) 881{ 882 fstring keystr; 883 TDB_DATA key; 884 TDB_DATA data; 885 pid_t updating_pid = sys_getpid(); 886 uint8 buffer[4]; 887 888 struct tdb_print_db *pdb = get_print_db_byname(sharename); 889 890 if (!pdb) 891 return; 892 893 slprintf(keystr, sizeof(keystr)-1, "UPDATING/%s", sharename); 894 key = string_tdb_data(keystr); 895 896 DEBUG(5, ("set_updating_pid: %s updating lpq cache for print share %s\n", 897 updating ? "" : "not ", 898 sharename )); 899 900 if ( !updating ) { 901 tdb_delete(pdb->tdb, key); 902 release_print_db(pdb); 903 return; 904 } 905 906 SIVAL( buffer, 0, updating_pid); 907 data.dptr = buffer; 908 data.dsize = 4; /* we always assume this is a 4 byte value */ 909 910 tdb_store(pdb->tdb, key, data, TDB_REPLACE); 911 release_print_db(pdb); 912} 913 914/**************************************************************************** 915 Sort print jobs by submittal time. 916****************************************************************************/ 917 918static int printjob_comp(print_queue_struct *j1, print_queue_struct *j2) 919{ 920 /* Silly cases */ 921 922 if (!j1 && !j2) 923 return 0; 924 if (!j1) 925 return -1; 926 if (!j2) 927 return 1; 928 929 /* Sort on job start time */ 930 931 if (j1->time == j2->time) 932 return 0; 933 return (j1->time > j2->time) ? 1 : -1; 934} 935 936/**************************************************************************** 937 Store the sorted queue representation for later portmon retrieval. 938 Skip deleted jobs 939****************************************************************************/ 940 941static void store_queue_struct(struct tdb_print_db *pdb, struct traverse_struct *pts) 942{ 943 TDB_DATA data; 944 int max_reported_jobs = lp_max_reported_jobs(pts->snum); 945 print_queue_struct *queue = pts->queue; 946 size_t len; 947 size_t i; 948 unsigned int qcount; 949 950 if (max_reported_jobs && (max_reported_jobs < pts->qcount)) 951 pts->qcount = max_reported_jobs; 952 qcount = 0; 953 954 /* Work out the size. */ 955 data.dsize = 0; 956 data.dsize += tdb_pack(NULL, 0, "d", qcount); 957 958 for (i = 0; i < pts->qcount; i++) { 959 if ( queue[i].status == LPQ_DELETED ) 960 continue; 961 962 qcount++; 963 data.dsize += tdb_pack(NULL, 0, "ddddddff", 964 (uint32)queue[i].job, 965 (uint32)queue[i].size, 966 (uint32)queue[i].page_count, 967 (uint32)queue[i].status, 968 (uint32)queue[i].priority, 969 (uint32)queue[i].time, 970 queue[i].fs_user, 971 queue[i].fs_file); 972 } 973 974 if ((data.dptr = (uint8 *)SMB_MALLOC(data.dsize)) == NULL) 975 return; 976 977 len = 0; 978 len += tdb_pack(data.dptr + len, data.dsize - len, "d", qcount); 979 for (i = 0; i < pts->qcount; i++) { 980 if ( queue[i].status == LPQ_DELETED ) 981 continue; 982 983 len += tdb_pack(data.dptr + len, data.dsize - len, "ddddddff", 984 (uint32)queue[i].job, 985 (uint32)queue[i].size, 986 (uint32)queue[i].page_count, 987 (uint32)queue[i].status, 988 (uint32)queue[i].priority, 989 (uint32)queue[i].time, 990 queue[i].fs_user, 991 queue[i].fs_file); 992 } 993 994 tdb_store(pdb->tdb, string_tdb_data("INFO/linear_queue_array"), data, 995 TDB_REPLACE); 996 SAFE_FREE(data.dptr); 997 return; 998} 999 1000static TDB_DATA get_jobs_changed_data(struct tdb_print_db *pdb) 1001{ 1002 TDB_DATA data; 1003 1004 ZERO_STRUCT(data); 1005 1006 data = tdb_fetch(pdb->tdb, string_tdb_data("INFO/jobs_changed")); 1007 if (data.dptr == NULL || data.dsize == 0 || (data.dsize % 4 != 0)) { 1008 SAFE_FREE(data.dptr); 1009 ZERO_STRUCT(data); 1010 } 1011 1012 return data; 1013} 1014 1015static void check_job_changed(const char *sharename, TDB_DATA data, uint32 jobid) 1016{ 1017 unsigned int i; 1018 unsigned int job_count = data.dsize / 4; 1019 1020 for (i = 0; i < job_count; i++) { 1021 uint32 ch_jobid; 1022 1023 ch_jobid = IVAL(data.dptr, i*4); 1024 if (ch_jobid == jobid) 1025 remove_from_jobs_changed(sharename, jobid); 1026 } 1027} 1028 1029/**************************************************************************** 1030 Check if the print queue has been updated recently enough. 1031****************************************************************************/ 1032 1033static bool print_cache_expired(const char *sharename, bool check_pending) 1034{ 1035 fstring key; 1036 time_t last_qscan_time, time_now = time(NULL); 1037 struct tdb_print_db *pdb = get_print_db_byname(sharename); 1038 bool result = False; 1039 1040 if (!pdb) 1041 return False; 1042 1043 snprintf(key, sizeof(key), "CACHE/%s", sharename); 1044 last_qscan_time = (time_t)tdb_fetch_int32(pdb->tdb, key); 1045 1046 /* 1047 * Invalidate the queue for 3 reasons. 1048 * (1). last queue scan time == -1. 1049 * (2). Current time - last queue scan time > allowed cache time. 1050 * (3). last queue scan time > current time + MAX_CACHE_VALID_TIME (1 hour by default). 1051 * This last test picks up machines for which the clock has been moved 1052 * forward, an lpq scan done and then the clock moved back. Otherwise 1053 * that last lpq scan would stay around for a loooong loooong time... :-). JRA. 1054 */ 1055 1056 if (last_qscan_time == ((time_t)-1) 1057 || (time_now - last_qscan_time) >= lp_lpqcachetime() 1058 || last_qscan_time > (time_now + MAX_CACHE_VALID_TIME)) 1059 { 1060 uint32 u; 1061 time_t msg_pending_time; 1062 1063 DEBUG(4, ("print_cache_expired: cache expired for queue %s " 1064 "(last_qscan_time = %d, time now = %d, qcachetime = %d)\n", 1065 sharename, (int)last_qscan_time, (int)time_now, 1066 (int)lp_lpqcachetime() )); 1067 1068 /* check if another smbd has already sent a message to update the 1069 queue. Give the pending message one minute to clear and 1070 then send another message anyways. Make sure to check for 1071 clocks that have been run forward and then back again. */ 1072 1073 snprintf(key, sizeof(key), "MSG_PENDING/%s", sharename); 1074 1075 if ( check_pending 1076 && tdb_fetch_uint32( pdb->tdb, key, &u ) 1077 && (msg_pending_time=u) > 0 1078 && msg_pending_time <= time_now 1079 && (time_now - msg_pending_time) < 60 ) 1080 { 1081 DEBUG(4,("print_cache_expired: message already pending for %s. Accepting cache\n", 1082 sharename)); 1083 goto done; 1084 } 1085 1086 result = True; 1087 } 1088 1089done: 1090 release_print_db(pdb); 1091 return result; 1092} 1093 1094/**************************************************************************** 1095 main work for updating the lpq cahe for a printer queue 1096****************************************************************************/ 1097 1098static void print_queue_update_internal( const char *sharename, 1099 struct printif *current_printif, 1100 char *lpq_command, char *lprm_command ) 1101{ 1102 int i, qcount; 1103 print_queue_struct *queue = NULL; 1104 print_status_struct status; 1105 print_status_struct old_status; 1106 struct printjob *pjob; 1107 struct traverse_struct tstruct; 1108 TDB_DATA data, key; 1109 TDB_DATA jcdata; 1110 fstring keystr, cachestr; 1111 struct tdb_print_db *pdb = get_print_db_byname(sharename); 1112 1113 if (!pdb) { 1114 return; 1115 } 1116 1117 DEBUG(5,("print_queue_update_internal: printer = %s, type = %d, lpq command = [%s]\n", 1118 sharename, current_printif->type, lpq_command)); 1119 1120 /* 1121 * Update the cache time FIRST ! Stops others even 1122 * attempting to get the lock and doing this 1123 * if the lpq takes a long time. 1124 */ 1125 1126 slprintf(cachestr, sizeof(cachestr)-1, "CACHE/%s", sharename); 1127 tdb_store_int32(pdb->tdb, cachestr, (int)time(NULL)); 1128 1129 /* get the current queue using the appropriate interface */ 1130 ZERO_STRUCT(status); 1131 1132 qcount = (*(current_printif->queue_get))(sharename, 1133 current_printif->type, 1134 lpq_command, &queue, &status); 1135 1136 DEBUG(3, ("print_queue_update_internal: %d job%s in queue for %s\n", 1137 qcount, (qcount != 1) ? "s" : "", sharename)); 1138 1139 /* Sort the queue by submission time otherwise they are displayed 1140 in hash order. */ 1141 1142 qsort(queue, qcount, sizeof(print_queue_struct), 1143 QSORT_CAST(printjob_comp)); 1144 1145 /* 1146 any job in the internal database that is marked as spooled 1147 and doesn't exist in the system queue is considered finished 1148 and removed from the database 1149 1150 any job in the system database but not in the internal database 1151 is added as a unix job 1152 1153 fill in any system job numbers as we go 1154 */ 1155 1156 jcdata = get_jobs_changed_data(pdb); 1157 1158 for (i=0; i<qcount; i++) { 1159 uint32 jobid = print_parse_jobid(queue[i].fs_file); 1160 1161 if (jobid == (uint32)-1) { 1162 /* assume its a unix print job */ 1163 print_unix_job(sharename, &queue[i], jobid); 1164 continue; 1165 } 1166 1167 /* we have an active SMB print job - update its status */ 1168 pjob = print_job_find(sharename, jobid); 1169 if (!pjob) { 1170 /* err, somethings wrong. Probably smbd was restarted 1171 with jobs in the queue. All we can do is treat them 1172 like unix jobs. Pity. */ 1173 print_unix_job(sharename, &queue[i], jobid); 1174 continue; 1175 } 1176 1177 pjob->sysjob = queue[i].job; 1178 1179 /* don't reset the status on jobs to be deleted */ 1180 1181 if ( pjob->status != LPQ_DELETING ) 1182 pjob->status = queue[i].status; 1183 1184 pjob_store(sharename, jobid, pjob); 1185 1186 check_job_changed(sharename, jcdata, jobid); 1187 } 1188 1189 SAFE_FREE(jcdata.dptr); 1190 1191 /* now delete any queued entries that don't appear in the 1192 system queue */ 1193 tstruct.queue = queue; 1194 tstruct.qcount = qcount; 1195 tstruct.snum = -1; 1196 tstruct.total_jobs = 0; 1197 tstruct.lpq_time = time(NULL); 1198 tstruct.sharename = sharename; 1199 tstruct.lprm_command = lprm_command; 1200 tstruct.print_if = current_printif; 1201 1202 tdb_traverse(pdb->tdb, traverse_fn_delete, (void *)&tstruct); 1203 1204 /* Store the linearised queue, max jobs only. */ 1205 store_queue_struct(pdb, &tstruct); 1206 1207 SAFE_FREE(tstruct.queue); 1208 1209 DEBUG(10,("print_queue_update_internal: printer %s INFO/total_jobs = %d\n", 1210 sharename, tstruct.total_jobs )); 1211 1212 tdb_store_int32(pdb->tdb, "INFO/total_jobs", tstruct.total_jobs); 1213 1214 get_queue_status(sharename, &old_status); 1215 if (old_status.qcount != qcount) 1216 DEBUG(10,("print_queue_update_internal: queue status change %d jobs -> %d jobs for printer %s\n", 1217 old_status.qcount, qcount, sharename)); 1218 1219 /* store the new queue status structure */ 1220 slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", sharename); 1221 key = string_tdb_data(keystr); 1222 1223 status.qcount = qcount; 1224 data.dptr = (uint8 *)&status; 1225 data.dsize = sizeof(status); 1226 tdb_store(pdb->tdb, key, data, TDB_REPLACE); 1227 1228 /* 1229 * Update the cache time again. We want to do this call 1230 * as little as possible... 1231 */ 1232 1233 slprintf(keystr, sizeof(keystr)-1, "CACHE/%s", sharename); 1234 tdb_store_int32(pdb->tdb, keystr, (int32)time(NULL)); 1235 1236 /* clear the msg pending record for this queue */ 1237 1238 snprintf(keystr, sizeof(keystr), "MSG_PENDING/%s", sharename); 1239 1240 if ( !tdb_store_uint32( pdb->tdb, keystr, 0 ) ) { 1241 /* log a message but continue on */ 1242 1243 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n", 1244 sharename)); 1245 } 1246 1247 release_print_db( pdb ); 1248 1249 return; 1250} 1251 1252/**************************************************************************** 1253 Update the internal database from the system print queue for a queue. 1254 obtain a lock on the print queue before proceeding (needed when mutiple 1255 smbd processes maytry to update the lpq cache concurrently). 1256****************************************************************************/ 1257 1258static void print_queue_update_with_lock( const char *sharename, 1259 struct printif *current_printif, 1260 char *lpq_command, char *lprm_command ) 1261{ 1262 fstring keystr; 1263 struct tdb_print_db *pdb; 1264 1265 DEBUG(5,("print_queue_update_with_lock: printer share = %s\n", sharename)); 1266 pdb = get_print_db_byname(sharename); 1267 if (!pdb) 1268 return; 1269 1270 if ( !print_cache_expired(sharename, False) ) { 1271 DEBUG(5,("print_queue_update_with_lock: print cache for %s is still ok\n", sharename)); 1272 release_print_db(pdb); 1273 return; 1274 } 1275 1276 /* 1277 * Check to see if someone else is doing this update. 1278 * This is essentially a mutex on the update. 1279 */ 1280 1281 if (get_updating_pid(sharename) != -1) { 1282 release_print_db(pdb); 1283 return; 1284 } 1285 1286 /* Lock the queue for the database update */ 1287 1288 slprintf(keystr, sizeof(keystr) - 1, "LOCK/%s", sharename); 1289 /* Only wait 10 seconds for this. */ 1290 if (tdb_lock_bystring_with_timeout(pdb->tdb, keystr, 10) == -1) { 1291 DEBUG(0,("print_queue_update_with_lock: Failed to lock printer %s database\n", sharename)); 1292 release_print_db(pdb); 1293 return; 1294 } 1295 1296 /* 1297 * Ensure that no one else got in here. 1298 * If the updating pid is still -1 then we are 1299 * the winner. 1300 */ 1301 1302 if (get_updating_pid(sharename) != -1) { 1303 /* 1304 * Someone else is doing the update, exit. 1305 */ 1306 tdb_unlock_bystring(pdb->tdb, keystr); 1307 release_print_db(pdb); 1308 return; 1309 } 1310 1311 /* 1312 * We're going to do the update ourselves. 1313 */ 1314 1315 /* Tell others we're doing the update. */ 1316 set_updating_pid(sharename, True); 1317 1318 /* 1319 * Allow others to enter and notice we're doing 1320 * the update. 1321 */ 1322 1323 tdb_unlock_bystring(pdb->tdb, keystr); 1324 1325 /* do the main work now */ 1326 1327 print_queue_update_internal( sharename, current_printif, 1328 lpq_command, lprm_command ); 1329 1330 /* Delete our pid from the db. */ 1331 set_updating_pid(sharename, False); 1332 release_print_db(pdb); 1333} 1334 1335/**************************************************************************** 1336this is the receive function of the background lpq updater 1337****************************************************************************/ 1338static void print_queue_receive(struct messaging_context *msg, 1339 void *private_data, 1340 uint32_t msg_type, 1341 struct server_id server_id, 1342 DATA_BLOB *data) 1343{ 1344 fstring sharename; 1345 char *lpqcommand = NULL, *lprmcommand = NULL; 1346 int printing_type; 1347 size_t len; 1348 1349 len = tdb_unpack( (uint8 *)data->data, data->length, "fdPP", 1350 sharename, 1351 &printing_type, 1352 &lpqcommand, 1353 &lprmcommand ); 1354 1355 if ( len == -1 ) { 1356 SAFE_FREE(lpqcommand); 1357 SAFE_FREE(lprmcommand); 1358 DEBUG(0,("print_queue_receive: Got invalid print queue update message\n")); 1359 return; 1360 } 1361 1362 print_queue_update_with_lock(sharename, 1363 get_printer_fns_from_type((enum printing_types)printing_type), 1364 lpqcommand, lprmcommand ); 1365 1366 SAFE_FREE(lpqcommand); 1367 SAFE_FREE(lprmcommand); 1368 return; 1369} 1370 1371static void printing_pause_fd_handler(struct tevent_context *ev, 1372 struct tevent_fd *fde, 1373 uint16_t flags, 1374 void *private_data) 1375{ 1376 /* 1377 * If pause_pipe[1] is closed it means the parent smbd 1378 * and children exited or aborted. 1379 */ 1380 exit_server_cleanly(NULL); 1381} 1382 1383static void add_child_pid(pid_t pid) 1384{ 1385 extern struct child_pid *children; 1386 struct child_pid *child; 1387 extern int num_children; 1388 1389 child = SMB_MALLOC_P(struct child_pid); 1390 if (child == NULL) { 1391 DEBUG(0, ("Could not add child struct -- malloc failed\n")); 1392 return; 1393 } 1394 child->pid = pid; 1395 DLIST_ADD(children, child); 1396 num_children += 1; 1397} 1398 1399static pid_t background_lpq_updater_pid = -1; 1400 1401/**************************************************************************** 1402main thread of the background lpq updater 1403****************************************************************************/ 1404void start_background_queue(void) 1405{ 1406 /* Use local variables for this as we don't 1407 * need to save the parent side of this, just 1408 * ensure it closes when the process exits. 1409 */ 1410 int pause_pipe[2]; 1411 1412 DEBUG(3,("start_background_queue: Starting background LPQ thread\n")); 1413 1414 if (pipe(pause_pipe) == -1) { 1415 DEBUG(5,("start_background_queue: cannot create pipe. %s\n", strerror(errno) )); 1416 exit(1); 1417 } 1418 1419 background_lpq_updater_pid = sys_fork(); 1420 1421 if (background_lpq_updater_pid == -1) { 1422 DEBUG(5,("start_background_queue: background LPQ thread failed to start. %s\n", strerror(errno) )); 1423 exit(1); 1424 } 1425 1426 /* Track the printing pid along with other smbd children */ 1427 add_child_pid(background_lpq_updater_pid); 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/**************************************************************************** 1480update the internal database from the system print queue for a queue 1481****************************************************************************/ 1482 1483static void print_queue_update(int snum, bool force) 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 1616bool print_notify_register_pid(int snum) 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 \ 1687list 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 1707bool print_notify_deregister_pid(int snum) 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 \ 1743printer %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 \ 1777list 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 1796bool print_job_exists(const char* sharename, uint32 jobid) 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 1813int print_job_fd(const char* sharename, uint32 jobid) 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 1830char *print_job_fname(const char* sharename, uint32 jobid) 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 1845NT_DEVICEMODE *print_job_devmode(const char* sharename, uint32 jobid) 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 1859bool print_job_set_place(const char *sharename, uint32 jobid, int place) 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 1869bool print_job_set_name(const char *sharename, uint32 jobid, char *name) 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 1885static bool remove_from_jobs_changed(const char* sharename, uint32 jobid) 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 1944static bool print_job_delete1(int snum, uint32 jobid) 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 2007static bool is_owner(struct auth_serversupplied_info *server_info, 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 2023bool print_job_delete(struct auth_serversupplied_info *server_info, int snum, 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, \ 2046pause, 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 2092bool print_job_pause(struct auth_serversupplied_info *server_info, int snum, 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, \ 2121pause, 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 2154bool print_job_resume(struct auth_serversupplied_info *server_info, int snum, 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, \ 2184pause, 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 2212ssize_t print_job_write(int snum, uint32 jobid, const char *buf, SMB_OFF_T pos, size_t size) 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 2239static int get_queue_status(const char* sharename, print_status_struct *status) 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 2273int print_queue_length(int snum, print_status_struct *pstatus) 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 2299static bool allocate_print_jobid(struct tdb_print_db *pdb, int snum, const char *sharename, uint32 *pjobid) 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 2373static bool add_to_jobs_changed(struct tdb_print_db *pdb, uint32 jobid) 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 2392uint32 print_job_start(struct auth_serversupplied_info *server_info, int snum, 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 = 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 \ 2492to 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 2527void print_job_endpage(int snum, uint32 jobid) 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 2549bool print_job_end(int snum, uint32 jobid, enum file_close_type close_type) 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, false) == 0)) { 2567 pjob->size = sbuf.st_ex_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 ret = (*(current_printif->job_submit))(snum, pjob); 2595 2596 if (ret) 2597 goto fail; 2598 2599 /* The print job has been successfully handed over to the back-end */ 2600 2601 pjob->spooled = True; 2602 pjob->status = LPQ_QUEUED; 2603 pjob_store(sharename, jobid, pjob); 2604 2605 /* make sure the database is up to date */ 2606 if (print_cache_expired(lp_const_servicename(snum), True)) 2607 print_queue_update(snum, False); 2608 2609 return True; 2610 2611fail: 2612 2613 /* The print job was not successfully started. Cleanup */ 2614 /* Still need to add proper error return propagation! 010122:JRR */ 2615 unlink(pjob->filename); 2616 pjob_delete(sharename, jobid); 2617 return False; 2618} 2619 2620/**************************************************************************** 2621 Get a snapshot of jobs in the system without traversing. 2622****************************************************************************/ 2623 2624static bool get_stored_queue_info(struct tdb_print_db *pdb, int snum, int *pcount, print_queue_struct **ppqueue) 2625{ 2626 TDB_DATA data, cgdata; 2627 print_queue_struct *queue = NULL; 2628 uint32 qcount = 0; 2629 uint32 extra_count = 0; 2630 int total_count = 0; 2631 size_t len = 0; 2632 uint32 i; 2633 int max_reported_jobs = lp_max_reported_jobs(snum); 2634 bool ret = False; 2635 const char* sharename = lp_servicename(snum); 2636 2637 /* make sure the database is up to date */ 2638 if (print_cache_expired(lp_const_servicename(snum), True)) 2639 print_queue_update(snum, False); 2640 2641 *pcount = 0; 2642 *ppqueue = NULL; 2643 2644 ZERO_STRUCT(data); 2645 ZERO_STRUCT(cgdata); 2646 2647 /* Get the stored queue data. */ 2648 data = tdb_fetch(pdb->tdb, string_tdb_data("INFO/linear_queue_array")); 2649 2650 if (data.dptr && data.dsize >= sizeof(qcount)) 2651 len += tdb_unpack(data.dptr + len, data.dsize - len, "d", &qcount); 2652 2653 /* Get the changed jobs list. */ 2654 cgdata = tdb_fetch(pdb->tdb, string_tdb_data("INFO/jobs_changed")); 2655 if (cgdata.dptr != NULL && (cgdata.dsize % 4 == 0)) 2656 extra_count = cgdata.dsize/4; 2657 2658 DEBUG(5,("get_stored_queue_info: qcount = %u, extra_count = %u\n", (unsigned int)qcount, (unsigned int)extra_count)); 2659 2660 /* Allocate the queue size. */ 2661 if (qcount == 0 && extra_count == 0) 2662 goto out; 2663 2664 if ((queue = SMB_MALLOC_ARRAY(print_queue_struct, qcount + extra_count)) == NULL) 2665 goto out; 2666 2667 /* Retrieve the linearised queue data. */ 2668 2669 for( i = 0; i < qcount; i++) { 2670 uint32 qjob, qsize, qpage_count, qstatus, qpriority, qtime; 2671 len += tdb_unpack(data.dptr + len, data.dsize - len, "ddddddff", 2672 &qjob, 2673 &qsize, 2674 &qpage_count, 2675 &qstatus, 2676 &qpriority, 2677 &qtime, 2678 queue[i].fs_user, 2679 queue[i].fs_file); 2680 queue[i].job = qjob; 2681 queue[i].size = qsize; 2682 queue[i].page_count = qpage_count; 2683 queue[i].status = qstatus; 2684 queue[i].priority = qpriority; 2685 queue[i].time = qtime; 2686 } 2687 2688 total_count = qcount; 2689 2690 /* Add in the changed jobids. */ 2691 for( i = 0; i < extra_count; i++) { 2692 uint32 jobid; 2693 struct printjob *pjob; 2694 2695 jobid = IVAL(cgdata.dptr, i*4); 2696 DEBUG(5,("get_stored_queue_info: changed job = %u\n", (unsigned int)jobid)); 2697 pjob = print_job_find(lp_const_servicename(snum), jobid); 2698 if (!pjob) { 2699 DEBUG(5,("get_stored_queue_info: failed to find changed job = %u\n", (unsigned int)jobid)); 2700 remove_from_jobs_changed(sharename, jobid); 2701 continue; 2702 } 2703 2704 queue[total_count].job = jobid; 2705 queue[total_count].size = pjob->size; 2706 queue[total_count].page_count = pjob->page_count; 2707 queue[total_count].status = pjob->status; 2708 queue[total_count].priority = 1; 2709 queue[total_count].time = pjob->starttime; 2710 fstrcpy(queue[total_count].fs_user, pjob->user); 2711 fstrcpy(queue[total_count].fs_file, pjob->jobname); 2712 total_count++; 2713 } 2714 2715 /* Sort the queue by submission time otherwise they are displayed 2716 in hash order. */ 2717 2718 qsort(queue, total_count, sizeof(print_queue_struct), QSORT_CAST(printjob_comp)); 2719 2720 DEBUG(5,("get_stored_queue_info: total_count = %u\n", (unsigned int)total_count)); 2721 2722 if (max_reported_jobs && total_count > max_reported_jobs) 2723 total_count = max_reported_jobs; 2724 2725 *ppqueue = queue; 2726 *pcount = total_count; 2727 2728 ret = True; 2729 2730 out: 2731 2732 SAFE_FREE(data.dptr); 2733 SAFE_FREE(cgdata.dptr); 2734 return ret; 2735} 2736 2737/**************************************************************************** 2738 Get a printer queue listing. 2739 set queue = NULL and status = NULL if you just want to update the cache 2740****************************************************************************/ 2741 2742int print_queue_status(int snum, 2743 print_queue_struct **ppqueue, 2744 print_status_struct *status) 2745{ 2746 fstring keystr; 2747 TDB_DATA data, key; 2748 const char *sharename; 2749 struct tdb_print_db *pdb; 2750 int count = 0; 2751 2752 /* make sure the database is up to date */ 2753 2754 if (print_cache_expired(lp_const_servicename(snum), True)) 2755 print_queue_update(snum, False); 2756 2757 /* return if we are done */ 2758 if ( !ppqueue || !status ) 2759 return 0; 2760 2761 *ppqueue = NULL; 2762 sharename = lp_const_servicename(snum); 2763 pdb = get_print_db_byname(sharename); 2764 2765 if (!pdb) 2766 return 0; 2767 2768 /* 2769 * Fetch the queue status. We must do this first, as there may 2770 * be no jobs in the queue. 2771 */ 2772 2773 ZERO_STRUCTP(status); 2774 slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", sharename); 2775 key = string_tdb_data(keystr); 2776 2777 data = tdb_fetch(pdb->tdb, key); 2778 if (data.dptr) { 2779 if (data.dsize == sizeof(*status)) { 2780 /* this memcpy is ok since the status struct was 2781 not packed before storing it in the tdb */ 2782 memcpy(status, data.dptr, sizeof(*status)); 2783 } 2784 SAFE_FREE(data.dptr); 2785 } 2786 2787 /* 2788 * Now, fetch the print queue information. We first count the number 2789 * of entries, and then only retrieve the queue if necessary. 2790 */ 2791 2792 if (!get_stored_queue_info(pdb, snum, &count, ppqueue)) { 2793 release_print_db(pdb); 2794 return 0; 2795 } 2796 2797 release_print_db(pdb); 2798 return count; 2799} 2800 2801/**************************************************************************** 2802 Pause a queue. 2803****************************************************************************/ 2804 2805WERROR print_queue_pause(struct auth_serversupplied_info *server_info, int snum) 2806{ 2807 int ret; 2808 struct printif *current_printif = get_printer_fns( snum ); 2809 2810 if (!print_access_check(server_info, snum, 2811 PRINTER_ACCESS_ADMINISTER)) { 2812 return WERR_ACCESS_DENIED; 2813 } 2814 2815 2816 become_root(); 2817 2818 ret = (*(current_printif->queue_pause))(snum); 2819 2820 unbecome_root(); 2821 2822 if (ret != 0) { 2823 return WERR_INVALID_PARAM; 2824 } 2825 2826 /* force update the database */ 2827 print_cache_flush(lp_const_servicename(snum)); 2828 2829 /* Send a printer notify message */ 2830 2831 notify_printer_status(snum, PRINTER_STATUS_PAUSED); 2832 2833 return WERR_OK; 2834} 2835 2836/**************************************************************************** 2837 Resume a queue. 2838****************************************************************************/ 2839 2840WERROR print_queue_resume(struct auth_serversupplied_info *server_info, int snum) 2841{ 2842 int ret; 2843 struct printif *current_printif = get_printer_fns( snum ); 2844 2845 if (!print_access_check(server_info, snum, 2846 PRINTER_ACCESS_ADMINISTER)) { 2847 return WERR_ACCESS_DENIED; 2848 } 2849 2850 become_root(); 2851 2852 ret = (*(current_printif->queue_resume))(snum); 2853 2854 unbecome_root(); 2855 2856 if (ret != 0) { 2857 return WERR_INVALID_PARAM; 2858 } 2859 2860 /* make sure the database is up to date */ 2861 if (print_cache_expired(lp_const_servicename(snum), True)) 2862 print_queue_update(snum, True); 2863 2864 /* Send a printer notify message */ 2865 2866 notify_printer_status(snum, PRINTER_STATUS_OK); 2867 2868 return WERR_OK; 2869} 2870 2871/**************************************************************************** 2872 Purge a queue - implemented by deleting all jobs that we can delete. 2873****************************************************************************/ 2874 2875WERROR print_queue_purge(struct auth_serversupplied_info *server_info, int snum) 2876{ 2877 print_queue_struct *queue; 2878 print_status_struct status; 2879 int njobs, i; 2880 bool can_job_admin; 2881 2882 /* Force and update so the count is accurate (i.e. not a cached count) */ 2883 print_queue_update(snum, True); 2884 2885 can_job_admin = print_access_check(server_info, snum, 2886 JOB_ACCESS_ADMINISTER); 2887 njobs = print_queue_status(snum, &queue, &status); 2888 2889 if ( can_job_admin ) 2890 become_root(); 2891 2892 for (i=0;i<njobs;i++) { 2893 bool owner = is_owner(server_info, lp_const_servicename(snum), 2894 queue[i].job); 2895 2896 if (owner || can_job_admin) { 2897 print_job_delete1(snum, queue[i].job); 2898 } 2899 } 2900 2901 if ( can_job_admin ) 2902 unbecome_root(); 2903 2904 /* update the cache */ 2905 print_queue_update( snum, True ); 2906 2907 SAFE_FREE(queue); 2908 2909 return WERR_OK; 2910} 2911