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