source3/printing/printing.c

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