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