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