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