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         release_print_db(pdb);
 831 done:
 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 bool print_job_pause(const struct auth_session_info *server_info,
2233                      struct messaging_context *msg_ctx,
2234                      int snum, uint32 jobid, WERROR *errcode)
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
2241         pjob = print_job_find(sharename, jobid);
2242
2243         if (!pjob || !server_info) {
2244                 DEBUG(10, ("print_job_pause: no pjob or user for jobid %u\n",
2245                         (unsigned int)jobid ));
2246                 return False;
2247         }
2248
2249         if (!pjob->spooled || pjob->sysjob == -1) {
2250                 DEBUG(10, ("print_job_pause: not spooled or bad sysjob = %d for jobid %u\n",
2251                         (int)pjob->sysjob, (unsigned int)jobid ));
2252                 return False;
2253         }
2254
2255         if (!is_owner(server_info, lp_const_servicename(snum), jobid) &&
2256             !print_access_check(server_info, msg_ctx, snum,
2257                                 JOB_ACCESS_ADMINISTER)) {
2258                 DEBUG(3, ("pause denied by security descriptor\n"));
2259
2260                 /* BEGIN_ADMIN_LOG */
2261                 sys_adminlog( LOG_ERR,
2262                         "Permission denied-- user not allowed to delete, \
2263 pause, or resume print job. User name: %s. Printer name: %s.",
2264                               uidtoname(server_info->unix_token->uid),
2265                               lp_printername(snum) );
2266                 /* END_ADMIN_LOG */
2267
2268                 *errcode = WERR_ACCESS_DENIED;
2269                 return False;
2270         }
2271
2272         /* need to pause the spooled entry */
2273         ret = (*(current_printif->job_pause))(snum, pjob);
2274
2275         if (ret != 0) {
2276                 *errcode = WERR_INVALID_PARAM;
2277                 return False;
2278         }
2279
2280         /* force update the database */
2281         print_cache_flush(lp_const_servicename(snum));
2282
2283         /* Send a printer notify message */
2284
2285         notify_job_status(server_event_context(), msg_ctx, sharename, jobid,
2286                           JOB_STATUS_PAUSED);
2287
2288         /* how do we tell if this succeeded? */
2289
2290         return True;
2291 }
2292
2293 /****************************************************************************
2294  Resume a job.
2295 ****************************************************************************/
2296
2297 bool print_job_resume(const struct auth_session_info *server_info,
2298                       struct messaging_context *msg_ctx,
2299                       int snum, uint32 jobid, WERROR *errcode)
2300 {
2301         const char *sharename = lp_const_servicename(snum);
2302         struct printjob *pjob;
2303         int ret;
2304         struct printif *current_printif = get_printer_fns( snum );
2305
2306         pjob = print_job_find(sharename, jobid);
2307
2308         if (!pjob || !server_info) {
2309                 DEBUG(10, ("print_job_resume: no pjob or user for jobid %u\n",
2310                         (unsigned int)jobid ));
2311                 return False;
2312         }
2313
2314         if (!pjob->spooled || pjob->sysjob == -1) {
2315                 DEBUG(10, ("print_job_resume: not spooled or bad sysjob = %d for jobid %u\n",
2316                         (int)pjob->sysjob, (unsigned int)jobid ));
2317                 return False;
2318         }
2319
2320         if (!is_owner(server_info, lp_const_servicename(snum), jobid) &&
2321             !print_access_check(server_info, msg_ctx, snum,
2322                                 JOB_ACCESS_ADMINISTER)) {
2323                 DEBUG(3, ("resume denied by security descriptor\n"));
2324                 *errcode = WERR_ACCESS_DENIED;
2325
2326                 /* BEGIN_ADMIN_LOG */
2327                 sys_adminlog( LOG_ERR,
2328                          "Permission denied-- user not allowed to delete, \
2329 pause, or resume print job. User name: %s. Printer name: %s.",
2330                               uidtoname(server_info->unix_token->uid),
2331                               lp_printername(snum) );
2332                 /* END_ADMIN_LOG */
2333                 return False;
2334         }
2335
2336         ret = (*(current_printif->job_resume))(snum, pjob);
2337
2338         if (ret != 0) {
2339                 *errcode = WERR_INVALID_PARAM;
2340                 return False;
2341         }
2342
2343         /* force update the database */
2344         print_cache_flush(lp_const_servicename(snum));
2345
2346         /* Send a printer notify message */
2347
2348         notify_job_status(server_event_context(), msg_ctx, sharename, jobid,
2349                           JOB_STATUS_QUEUED);
2350
2351         return True;
2352 }
2353
2354 /****************************************************************************
2355  Write to a print file.
2356 ****************************************************************************/
2357
2358 ssize_t print_job_write(struct tevent_context *ev,
2359                         struct messaging_context *msg_ctx,
2360                         int snum, uint32 jobid, const char *buf, size_t size)
2361 {
2362         const char* sharename = lp_const_servicename(snum);
2363         ssize_t return_code;
2364         struct printjob *pjob;
2365
2366         pjob = print_job_find(sharename, jobid);
2367
2368         if (!pjob)
2369                 return -1;
2370         /* don't allow another process to get this info - it is meaningless */
2371         if (pjob->pid != getpid())
2372                 return -1;
2373
2374         /* if SMBD is spooling this can't be allowed */
2375         if (pjob->status == PJOB_SMBD_SPOOLING) {
2376                 return -1;
2377         }
2378
2379         return_code = write_data(pjob->fd, buf, size);
2380
2381         if (return_code>0) {
2382                 pjob->size += size;
2383                 pjob_store(ev, msg_ctx, sharename, jobid, pjob);
2384         }
2385         return return_code;
2386 }
2387
2388 /****************************************************************************
2389  Get the queue status - do not update if db is out of date.
2390 ****************************************************************************/
2391
2392 static int get_queue_status(const char* sharename, print_status_struct *status)
2393 {
2394         fstring keystr;
2395         TDB_DATA data;
2396         struct tdb_print_db *pdb = get_print_db_byname(sharename);
2397         int len;
2398
2399         if (status) {
2400                 ZERO_STRUCTP(status);
2401         }
2402
2403         if (!pdb)
2404                 return 0;
2405
2406         if (status) {
2407                 fstr_sprintf(keystr, "STATUS/%s", sharename);
2408                 data = tdb_fetch_compat(pdb->tdb, string_tdb_data(keystr));
2409                 if (data.dptr) {
2410                         if (data.dsize == sizeof(print_status_struct))
2411                                 /* this memcpy is ok since the status struct was
2412                                    not packed before storing it in the tdb */
2413                                 memcpy(status, data.dptr, sizeof(print_status_struct));
2414                         SAFE_FREE(data.dptr);
2415                 }
2416         }
2417         len = tdb_fetch_int32(pdb->tdb, "INFO/total_jobs");
2418         release_print_db(pdb);
2419         return (len == -1 ? 0 : len);
2420 }
2421
2422 /****************************************************************************
2423  Determine the number of jobs in a queue.
2424 ****************************************************************************/
2425
2426 int print_queue_length(struct messaging_context *msg_ctx, int snum,
2427                        print_status_struct *pstatus)
2428 {
2429         const char* sharename = lp_const_servicename( snum );
2430         print_status_struct status;
2431         int len;
2432
2433         ZERO_STRUCT( status );
2434
2435         /* make sure the database is up to date */
2436         if (print_cache_expired(lp_const_servicename(snum), True))
2437                 print_queue_update(msg_ctx, snum, False);
2438
2439         /* also fetch the queue status */
2440         memset(&status, 0, sizeof(status));
2441         len = get_queue_status(sharename, &status);
2442
2443         if (pstatus)
2444                 *pstatus = status;
2445
2446         return len;
2447 }
2448
2449 /***************************************************************************
2450  Allocate a jobid. Hold the lock for as short a time as possible.
2451 ***************************************************************************/
2452
2453 static WERROR allocate_print_jobid(struct tdb_print_db *pdb, int snum,
2454                                    const char *sharename, uint32 *pjobid)
2455 {
2456         int i;
2457         uint32 jobid;
2458         enum TDB_ERROR terr;
2459         int ret;
2460
2461         *pjobid = (uint32)-1;
2462
2463         for (i = 0; i < 3; i++) {
2464                 /* Lock the database - only wait 20 seconds. */
2465                 ret = tdb_lock_bystring_with_timeout(pdb->tdb,
2466                                                      "INFO/nextjob", 20);
2467                 if (ret != 0) {
2468                         DEBUG(0, ("allocate_print_jobid: "
2469                                   "Failed to lock printing database %s\n",
2470                                   sharename));
2471                         terr = tdb_error(pdb->tdb);
2472                         return ntstatus_to_werror(map_nt_error_from_tdb(terr));
2473                 }
2474
2475                 if (!tdb_fetch_uint32(pdb->tdb, "INFO/nextjob", &jobid)) {
2476                         terr = tdb_error(pdb->tdb);
2477                         if (terr != TDB_ERR_NOEXIST) {
2478                                 DEBUG(0, ("allocate_print_jobid: "
2479                                           "Failed to fetch INFO/nextjob "
2480                                           "for print queue %s\n", sharename));
2481                                 tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
2482                                 return ntstatus_to_werror(map_nt_error_from_tdb(terr));
2483                         }
2484                         DEBUG(10, ("allocate_print_jobid: "
2485                                    "No existing jobid in %s\n", sharename));
2486                         jobid = 0;
2487                 }
2488
2489                 DEBUG(10, ("allocate_print_jobid: "
2490                            "Read jobid %u from %s\n", jobid, sharename));
2491
2492                 jobid = NEXT_JOBID(jobid);
2493
2494                 ret = tdb_store_int32(pdb->tdb, "INFO/nextjob", jobid);
2495                 if (ret != 0) {
2496                         terr = tdb_error(pdb->tdb);
2497                         DEBUG(3, ("allocate_print_jobid: "
2498                                   "Failed to store INFO/nextjob.\n"));
2499                         tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
2500                         return ntstatus_to_werror(map_nt_error_from_tdb(terr));
2501                 }
2502
2503                 /* We've finished with the INFO/nextjob lock. */
2504                 tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
2505
2506                 if (!print_job_exists(sharename, jobid)) {
2507                         break;
2508                 }
2509                 DEBUG(10, ("allocate_print_jobid: "
2510                            "Found jobid %u in %s\n", jobid, sharename));
2511         }
2512
2513         if (i > 2) {
2514                 DEBUG(0, ("allocate_print_jobid: "
2515                           "Failed to allocate a print job for queue %s\n",
2516                           sharename));
2517                 /* Probably full... */
2518                 return WERR_NO_SPOOL_SPACE;
2519         }
2520
2521         /* Store a dummy placeholder. */
2522         {
2523                 uint32_t tmp;
2524                 TDB_DATA dum;
2525                 dum.dptr = NULL;
2526                 dum.dsize = 0;
2527                 if (tdb_store(pdb->tdb, print_key(jobid, &tmp), dum,
2528                               TDB_INSERT) != 0) {
2529                         DEBUG(3, ("allocate_print_jobid: "
2530                                   "jobid (%d) failed to store placeholder.\n",
2531                                   jobid ));
2532                         terr = tdb_error(pdb->tdb);
2533                         return ntstatus_to_werror(map_nt_error_from_tdb(terr));
2534                 }
2535         }
2536
2537         *pjobid = jobid;
2538         return WERR_OK;
2539 }
2540
2541 /***************************************************************************
2542  Append a jobid to the 'jobs added' list.
2543 ***************************************************************************/
2544
2545 static bool add_to_jobs_added(struct tdb_print_db *pdb, uint32 jobid)
2546 {
2547         TDB_DATA data;
2548         uint32 store_jobid;
2549
2550         SIVAL(&store_jobid, 0, jobid);
2551         data.dptr = (uint8 *)&store_jobid;
2552         data.dsize = 4;
2553
2554         DEBUG(10,("add_to_jobs_added: Added jobid %u\n", (unsigned int)jobid ));
2555
2556         return (tdb_append(pdb->tdb, string_tdb_data("INFO/jobs_added"),
2557                            data) == 0);
2558 }
2559
2560
2561 /***************************************************************************
2562  Do all checks needed to determine if we can start a job.
2563 ***************************************************************************/
2564
2565 static WERROR print_job_checks(const struct auth_session_info *server_info,
2566                                struct messaging_context *msg_ctx,
2567                                int snum, int *njobs)
2568 {
2569         const char *sharename = lp_const_servicename(snum);
2570         uint64_t dspace, dsize;
2571         uint64_t minspace;
2572         int ret;
2573
2574         if (!print_access_check(server_info, msg_ctx, snum,
2575                                 PRINTER_ACCESS_USE)) {
2576                 DEBUG(3, ("print_job_checks: "
2577                           "job start denied by security descriptor\n"));
2578                 return WERR_ACCESS_DENIED;
2579         }
2580
2581         if (!print_time_access_check(server_info, msg_ctx, sharename)) {
2582                 DEBUG(3, ("print_job_checks: "
2583                           "job start denied by time check\n"));
2584                 return WERR_ACCESS_DENIED;
2585         }
2586
2587         /* see if we have sufficient disk space */
2588         if (lp_minprintspace(snum)) {
2589                 minspace = lp_minprintspace(snum);
2590                 ret = sys_fsusage(lp_pathname(snum), &dspace, &dsize);
2591                 if (ret == 0 && dspace < 2*minspace) {
2592                         DEBUG(3, ("print_job_checks: "
2593                                   "disk space check failed.\n"));
2594                         return WERR_NO_SPOOL_SPACE;
2595                 }
2596         }
2597
2598         /* for autoloaded printers, check that the printcap entry still exists */
2599         if (lp_autoloaded(snum) && !pcap_printername_ok(sharename)) {
2600                 DEBUG(3, ("print_job_checks: printer name %s check failed.\n",
2601                           sharename));
2602                 return WERR_ACCESS_DENIED;
2603         }
2604
2605         /* Insure the maximum queue size is not violated */
2606         *njobs = print_queue_length(msg_ctx, snum, NULL);
2607         if (*njobs > lp_maxprintjobs(snum)) {
2608                 DEBUG(3, ("print_job_checks: Queue %s number of jobs (%d) "
2609                           "larger than max printjobs per queue (%d).\n",
2610                           sharename, *njobs, lp_maxprintjobs(snum)));
2611                 return WERR_NO_SPOOL_SPACE;
2612         }
2613
2614         return WERR_OK;
2615 }
2616
2617 /***************************************************************************
2618  Create a job file.
2619 ***************************************************************************/
2620
2621 static WERROR print_job_spool_file(int snum, uint32_t jobid,
2622                                    const char *output_file,
2623                                    struct printjob *pjob)
2624 {
2625         WERROR werr;
2626         SMB_STRUCT_STAT st;
2627         const char *path;
2628         int len;
2629
2630         /* if this file is within the printer path, it means that smbd
2631          * is spooling it and will pass us control when it is finished.
2632          * Verify that the file name is ok, within path, and it is
2633          * already already there */
2634         if (output_file) {
2635                 path = lp_pathname(snum);
2636                 len = strlen(path);
2637                 if (strncmp(output_file, path, len) == 0 &&
2638                     (output_file[len - 1] == '/' || output_file[len] == '/')) {
2639
2640                         /* verify path is not too long */
2641                         if (strlen(output_file) >= sizeof(pjob->filename)) {
2642                                 return WERR_INVALID_NAME;
2643                         }
2644
2645                         /* verify that the file exists */
2646                         if (sys_stat(output_file, &st, false) != 0) {
2647                                 return WERR_INVALID_NAME;
2648                         }
2649
2650                         fstrcpy(pjob->filename, output_file);
2651
2652                         DEBUG(3, ("print_job_spool_file:"
2653                                   "External spooling activated"));
2654
2655                         /* we do not open the file until spooling is done */
2656                         pjob->fd = -1;
2657                         pjob->status = PJOB_SMBD_SPOOLING;
2658
2659                         return WERR_OK;
2660                 }
2661         }
2662
2663         slprintf(pjob->filename, sizeof(pjob->filename)-1,
2664                  "%s/%s%.8u.XXXXXX", lp_pathname(snum),
2665                  PRINT_SPOOL_PREFIX, (unsigned int)jobid);
2666         pjob->fd = mkstemp(pjob->filename);
2667
2668         if (pjob->fd == -1) {
2669                 werr = map_werror_from_unix(errno);
2670                 if (W_ERROR_EQUAL(werr, WERR_ACCESS_DENIED)) {
2671                         /* Common setup error, force a report. */
2672                         DEBUG(0, ("print_job_spool_file: "
2673                                   "insufficient permissions to open spool "
2674                                   "file %s.\n", pjob->filename));
2675                 } else {
2676                         /* Normal case, report at level 3 and above. */
2677                         DEBUG(3, ("print_job_spool_file: "
2678                                   "can't open spool file %s\n",
2679                                   pjob->filename));
2680                 }
2681                 return werr;
2682         }
2683
2684         return WERR_OK;
2685 }
2686
2687 /***************************************************************************
2688  Start spooling a job - return the jobid.
2689 ***************************************************************************/
2690
2691 WERROR print_job_start(const struct auth_session_info *server_info,
2692                        struct messaging_context *msg_ctx,
2693                        const char *clientmachine,
2694                        int snum, const char *docname, const char *filename,
2695                        struct spoolss_DeviceMode *devmode, uint32_t *_jobid)
2696 {
2697         uint32_t jobid;
2698         char *path;
2699         struct printjob pjob;
2700         const char *sharename = lp_const_servicename(snum);
2701         struct tdb_print_db *pdb = get_print_db_byname(sharename);
2702         int njobs;
2703         WERROR werr;
2704
2705         if (!pdb) {
2706                 return WERR_INTERNAL_DB_CORRUPTION;
2707         }
2708
2709         path = lp_pathname(snum);
2710
2711         werr = print_job_checks(server_info, msg_ctx, snum, &njobs);
2712         if (!W_ERROR_IS_OK(werr)) {
2713                 release_print_db(pdb);
2714                 return werr;
2715         }
2716
2717         DEBUG(10, ("print_job_start: "
2718                    "Queue %s number of jobs (%d), max printjobs = %d\n",
2719                    sharename, njobs, lp_maxprintjobs(snum)));
2720
2721         werr = allocate_print_jobid(pdb, snum, sharename, &jobid);
2722         if (!W_ERROR_IS_OK(werr)) {
2723                 goto fail;
2724         }
2725
2726         /* create the database entry */
2727
2728         ZERO_STRUCT(pjob);
2729
2730         pjob.pid = getpid();
2731         pjob.jobid = jobid;
2732         pjob.sysjob = -1;
2733         pjob.fd = -1;
2734         pjob.starttime = time(NULL);
2735         pjob.status = LPQ_SPOOLING;
2736         pjob.size = 0;
2737         pjob.spooled = False;
2738         pjob.smbjob = True;
2739         pjob.devmode = devmode;
2740
2741         fstrcpy(pjob.jobname, docname);
2742
2743         fstrcpy(pjob.clientmachine, clientmachine);
2744
2745         fstrcpy(pjob.user, lp_printjob_username(snum));
2746         standard_sub_advanced(sharename, server_info->unix_info->sanitized_username,
2747                               path, server_info->unix_token->gid,
2748                               server_info->unix_info->sanitized_username,
2749                               server_info->info->domain_name,
2750                               pjob.user, sizeof(pjob.user));
2751
2752         fstrcpy(pjob.queuename, lp_const_servicename(snum));
2753
2754         /* we have a job entry - now create the spool file */
2755         werr = print_job_spool_file(snum, jobid, filename, &pjob);
2756         if (!W_ERROR_IS_OK(werr)) {
2757                 goto fail;
2758         }
2759
2760         pjob_store(server_event_context(), msg_ctx, sharename, jobid, &pjob);
2761
2762         /* Update the 'jobs added' entry used by print_queue_status. */
2763         add_to_jobs_added(pdb, jobid);
2764
2765         /* Ensure we keep a rough count of the number of total jobs... */
2766         tdb_change_int32_atomic(pdb->tdb, "INFO/total_jobs", &njobs, 1);
2767
2768         release_print_db(pdb);
2769
2770         *_jobid = jobid;
2771         return WERR_OK;
2772
2773 fail:
2774         if (jobid != -1) {
2775                 pjob_delete(server_event_context(), msg_ctx, sharename, jobid);
2776         }
2777
2778         release_print_db(pdb);
2779
2780         DEBUG(3, ("print_job_start: returning fail. "
2781                   "Error = %s\n", win_errstr(werr)));
2782         return werr;
2783 }
2784
2785 /****************************************************************************
2786  Update the number of pages spooled to jobid
2787 ****************************************************************************/
2788
2789 void print_job_endpage(struct messaging_context *msg_ctx,
2790                        int snum, uint32 jobid)
2791 {
2792         const char* sharename = lp_const_servicename(snum);
2793         struct printjob *pjob;
2794
2795         pjob = print_job_find(sharename, jobid);
2796         if (!pjob)
2797                 return;
2798         /* don't allow another process to get this info - it is meaningless */
2799         if (pjob->pid != getpid())
2800                 return;
2801
2802         pjob->page_count++;
2803         pjob_store(server_event_context(), msg_ctx, sharename, jobid, pjob);
2804 }
2805
2806 /****************************************************************************
2807  Print a file - called on closing the file. This spools the job.
2808  If normal close is false then we're tearing down the jobs - treat as an
2809  error.
2810 ****************************************************************************/
2811
2812 NTSTATUS print_job_end(struct messaging_context *msg_ctx, int snum,
2813                        uint32 jobid, enum file_close_type close_type)
2814 {
2815         const char* sharename = lp_const_servicename(snum);
2816         struct printjob *pjob;
2817         int ret;
2818         SMB_STRUCT_STAT sbuf;
2819         struct printif *current_printif = get_printer_fns( snum );
2820         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
2821
2822         pjob = print_job_find(sharename, jobid);
2823
2824         if (!pjob) {
2825                 return NT_STATUS_PRINT_CANCELLED;
2826         }
2827
2828         if (pjob->spooled || pjob->pid != getpid()) {
2829                 return NT_STATUS_ACCESS_DENIED;
2830         }
2831
2832         if (close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) {
2833                 if (pjob->status == PJOB_SMBD_SPOOLING) {
2834                         /* take over the file now, smbd is done */
2835                         if (sys_stat(pjob->filename, &sbuf, false) != 0) {
2836                                 status = map_nt_error_from_unix(errno);
2837                                 DEBUG(3, ("print_job_end: "
2838                                           "stat file failed for jobid %d\n",
2839                                           jobid));
2840                                 goto fail;
2841                         }
2842
2843                         pjob->status = LPQ_SPOOLING;
2844
2845                 } else {
2846
2847                         if ((sys_fstat(pjob->fd, &sbuf, false) != 0)) {
2848                                 status = map_nt_error_from_unix(errno);
2849                                 close(pjob->fd);
2850                                 DEBUG(3, ("print_job_end: "
2851                                           "stat file failed for jobid %d\n",
2852                                           jobid));
2853                                 goto fail;
2854                         }
2855
2856                         close(pjob->fd);
2857                 }
2858
2859                 pjob->size = sbuf.st_ex_size;
2860         } else {
2861
2862                 /*
2863                  * Not a normal close, something has gone wrong. Cleanup.
2864                  */
2865                 if (pjob->fd != -1) {
2866                         close(pjob->fd);
2867                 }
2868                 goto fail;
2869         }
2870
2871         /* Technically, this is not quite right. If the printer has a separator
2872          * page turned on, the NT spooler prints the separator page even if the
2873          * print job is 0 bytes. 010215 JRR */
2874         if (pjob->size == 0 || pjob->status == LPQ_DELETING) {
2875                 /* don't bother spooling empty files or something being deleted. */
2876                 DEBUG(5,("print_job_end: canceling spool of %s (%s)\n",
2877                         pjob->filename, pjob->size ? "deleted" : "zero length" ));
2878                 unlink(pjob->filename);
2879                 pjob_delete(server_event_context(), msg_ctx, sharename, jobid);
2880                 return NT_STATUS_OK;
2881         }
2882
2883         ret = (*(current_printif->job_submit))(snum, pjob);
2884
2885         if (ret) {
2886                 status = NT_STATUS_PRINT_CANCELLED;
2887                 goto fail;
2888         }
2889
2890         /* The print job has been successfully handed over to the back-end */
2891
2892         pjob->spooled = True;
2893         pjob->status = LPQ_QUEUED;
2894         pjob_store(server_event_context(), msg_ctx, sharename, jobid, pjob);
2895
2896         /* make sure the database is up to date */
2897         if (print_cache_expired(lp_const_servicename(snum), True))
2898                 print_queue_update(msg_ctx, snum, False);
2899
2900         return NT_STATUS_OK;
2901
2902 fail:
2903
2904         /* The print job was not successfully started. Cleanup */
2905         /* Still need to add proper error return propagation! 010122:JRR */
2906         pjob->fd = -1;
2907         unlink(pjob->filename);
2908         pjob_delete(server_event_context(), msg_ctx, sharename, jobid);
2909         return status;
2910 }
2911
2912 /****************************************************************************
2913  Get a snapshot of jobs in the system without traversing.
2914 ****************************************************************************/
2915
2916 static bool get_stored_queue_info(struct messaging_context *msg_ctx,
2917                                   struct tdb_print_db *pdb, int snum,
2918                                   int *pcount, print_queue_struct **ppqueue)
2919 {
2920         TDB_DATA data, cgdata, jcdata;
2921         print_queue_struct *queue = NULL;
2922         uint32 qcount = 0;
2923         uint32 extra_count = 0;
2924         uint32_t changed_count = 0;
2925         int total_count = 0;
2926         size_t len = 0;
2927         uint32 i;
2928         int max_reported_jobs = lp_max_reported_jobs(snum);
2929         bool ret = False;
2930         const char* sharename = lp_servicename(snum);
2931
2932         /* make sure the database is up to date */
2933         if (print_cache_expired(lp_const_servicename(snum), True))
2934                 print_queue_update(msg_ctx, snum, False);
2935
2936         *pcount = 0;
2937         *ppqueue = NULL;
2938
2939         ZERO_STRUCT(data);
2940         ZERO_STRUCT(cgdata);
2941
2942         /* Get the stored queue data. */
2943         data = tdb_fetch_compat(pdb->tdb, string_tdb_data("INFO/linear_queue_array"));
2944
2945         if (data.dptr && data.dsize >= sizeof(qcount))
2946                 len += tdb_unpack(data.dptr + len, data.dsize - len, "d", &qcount);
2947
2948         /* Get the added jobs list. */
2949         cgdata = tdb_fetch_compat(pdb->tdb, string_tdb_data("INFO/jobs_added"));
2950         if (cgdata.dptr != NULL && (cgdata.dsize % 4 == 0))
2951                 extra_count = cgdata.dsize/4;
2952
2953         /* Get the changed jobs list. */
2954         jcdata = tdb_fetch_compat(pdb->tdb, string_tdb_data("INFO/jobs_changed"));
2955         if (jcdata.dptr != NULL && (jcdata.dsize % 4 == 0))
2956                 changed_count = jcdata.dsize / 4;
2957
2958         DEBUG(5,("get_stored_queue_info: qcount = %u, extra_count = %u\n", (unsigned int)qcount, (unsigned int)extra_count));
2959
2960         /* Allocate the queue size. */
2961         if (qcount == 0 && extra_count == 0)
2962                 goto out;
2963
2964         if ((queue = SMB_MALLOC_ARRAY(print_queue_struct, qcount + extra_count)) == NULL)
2965                 goto out;
2966
2967         /* Retrieve the linearised queue data. */
2968
2969         for( i  = 0; i < qcount; i++) {
2970                 uint32 qjob, qsize, qpage_count, qstatus, qpriority, qtime;
2971                 len += tdb_unpack(data.dptr + len, data.dsize - len, "ddddddff",
2972                                 &qjob,
2973                                 &qsize,
2974                                 &qpage_count,
2975                                 &qstatus,
2976                                 &qpriority,
2977                                 &qtime,
2978                                 queue[i].fs_user,
2979                                 queue[i].fs_file);
2980                 queue[i].sysjob = qjob;
2981                 queue[i].size = qsize;
2982                 queue[i].page_count = qpage_count;
2983                 queue[i].status = qstatus;
2984                 queue[i].priority = qpriority;
2985                 queue[i].time = qtime;
2986         }
2987
2988         total_count = qcount;
2989
2990         /* Add new jobids to the queue. */
2991         for( i  = 0; i < extra_count; i++) {
2992                 uint32 jobid;
2993                 struct printjob *pjob;
2994
2995                 jobid = IVAL(cgdata.dptr, i*4);
2996                 DEBUG(5,("get_stored_queue_info: added job = %u\n", (unsigned int)jobid));
2997                 pjob = print_job_find(lp_const_servicename(snum), jobid);
2998                 if (!pjob) {
2999                         DEBUG(5,("get_stored_queue_info: failed to find added job = %u\n", (unsigned int)jobid));
3000                         remove_from_jobs_added(sharename, jobid);
3001                         continue;
3002                 }
3003
3004                 queue[total_count].sysjob = jobid;
3005                 queue[total_count].size = pjob->size;
3006                 queue[total_count].page_count = pjob->page_count;
3007                 queue[total_count].status = pjob->status;
3008                 queue[total_count].priority = 1;
3009                 queue[total_count].time = pjob->starttime;
3010                 fstrcpy(queue[total_count].fs_user, pjob->user);
3011                 fstrcpy(queue[total_count].fs_file, pjob->jobname);
3012                 total_count++;
3013         }
3014
3015         /* Update the changed jobids. */
3016         for (i = 0; i < changed_count; i++) {
3017                 uint32_t jobid = IVAL(jcdata.dptr, i * 4);
3018                 uint32_t j;
3019                 bool found = false;
3020
3021                 for (j = 0; j < total_count; j++) {
3022                         if (queue[j].sysjob == jobid) {
3023                                 found = true;
3024                                 break;
3025                         }
3026                 }
3027
3028                 if (found) {
3029                         struct printjob *pjob;
3030
3031                         DEBUG(5,("get_stored_queue_info: changed job: %u\n",
3032                                  (unsigned int) jobid));
3033
3034                         pjob = print_job_find(sharename, jobid);
3035                         if (pjob == NULL) {
3036                                 DEBUG(5,("get_stored_queue_info: failed to find "
3037                                          "changed job = %u\n",
3038                                          (unsigned int) jobid));
3039                                 remove_from_jobs_changed(sharename, jobid);
3040                                 continue;
3041                         }
3042
3043                         queue[j].sysjob = jobid;
3044                         queue[j].size = pjob->size;
3045                         queue[j].page_count = pjob->page_count;
3046                         queue[j].status = pjob->status;
3047                         queue[j].priority = 1;
3048                         queue[j].time = pjob->starttime;
3049                         fstrcpy(queue[j].fs_user, pjob->user);
3050                         fstrcpy(queue[j].fs_file, pjob->jobname);
3051
3052                         DEBUG(5,("get_stored_queue_info: updated queue[%u], jobid: %u, jobname: %s\n",
3053                                  (unsigned int) j, (unsigned int) jobid, pjob->jobname));
3054                 }
3055
3056                 remove_from_jobs_changed(sharename, jobid);
3057         }
3058
3059         /* Sort the queue by submission time otherwise they are displayed
3060            in hash order. */
3061
3062         TYPESAFE_QSORT(queue, total_count, printjob_comp);
3063
3064         DEBUG(5,("get_stored_queue_info: total_count = %u\n", (unsigned int)total_count));
3065
3066         if (max_reported_jobs && total_count > max_reported_jobs)
3067                 total_count = max_reported_jobs;
3068
3069         *ppqueue = queue;
3070         *pcount = total_count;
3071
3072         ret = True;
3073
3074   out:
3075
3076         SAFE_FREE(data.dptr);
3077         SAFE_FREE(cgdata.dptr);
3078         return ret;
3079 }
3080
3081 /****************************************************************************
3082  Get a printer queue listing.
3083  set queue = NULL and status = NULL if you just want to update the cache
3084 ****************************************************************************/
3085
3086 int print_queue_status(struct messaging_context *msg_ctx, int snum,
3087                        print_queue_struct **ppqueue,
3088                        print_status_struct *status)
3089 {
3090         fstring keystr;
3091         TDB_DATA data, key;
3092         const char *sharename;
3093         struct tdb_print_db *pdb;
3094         int count = 0;
3095
3096         /* make sure the database is up to date */
3097
3098         if (print_cache_expired(lp_const_servicename(snum), True))
3099                 print_queue_update(msg_ctx, snum, False);
3100
3101         /* return if we are done */
3102         if ( !ppqueue || !status )
3103                 return 0;
3104
3105         *ppqueue = NULL;
3106         sharename = lp_const_servicename(snum);
3107         pdb = get_print_db_byname(sharename);
3108
3109         if (!pdb)
3110                 return 0;
3111
3112         /*
3113          * Fetch the queue status.  We must do this first, as there may
3114          * be no jobs in the queue.
3115          */
3116
3117         ZERO_STRUCTP(status);
3118         slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", sharename);
3119         key = string_tdb_data(keystr);
3120
3121         data = tdb_fetch_compat(pdb->tdb, key);
3122         if (data.dptr) {
3123                 if (data.dsize == sizeof(*status)) {
3124                         /* this memcpy is ok since the status struct was
3125                            not packed before storing it in the tdb */
3126                         memcpy(status, data.dptr, sizeof(*status));
3127                 }
3128                 SAFE_FREE(data.dptr);
3129         }
3130
3131         /*
3132          * Now, fetch the print queue information.  We first count the number
3133          * of entries, and then only retrieve the queue if necessary.
3134          */
3135
3136         if (!get_stored_queue_info(msg_ctx, pdb, snum, &count, ppqueue)) {
3137                 release_print_db(pdb);
3138                 return 0;
3139         }
3140
3141         release_print_db(pdb);
3142         return count;
3143 }
3144
3145 /****************************************************************************
3146  Pause a queue.
3147 ****************************************************************************/
3148
3149 WERROR print_queue_pause(const struct auth_session_info *server_info,
3150                          struct messaging_context *msg_ctx, int snum)
3151 {
3152         int ret;
3153         struct printif *current_printif = get_printer_fns( snum );
3154
3155         if (!print_access_check(server_info, msg_ctx, snum,
3156                                 PRINTER_ACCESS_ADMINISTER)) {
3157                 return WERR_ACCESS_DENIED;
3158         }
3159
3160
3161         become_root();
3162
3163         ret = (*(current_printif->queue_pause))(snum);
3164
3165         unbecome_root();
3166
3167         if (ret != 0) {
3168                 return WERR_INVALID_PARAM;
3169         }
3170
3171         /* force update the database */
3172         print_cache_flush(lp_const_servicename(snum));
3173
3174         /* Send a printer notify message */
3175
3176         notify_printer_status(server_event_context(), msg_ctx, snum,
3177                               PRINTER_STATUS_PAUSED);
3178
3179         return WERR_OK;
3180 }
3181
3182 /****************************************************************************
3183  Resume a queue.
3184 ****************************************************************************/
3185
3186 WERROR print_queue_resume(const struct auth_session_info *server_info,
3187                           struct messaging_context *msg_ctx, int snum)
3188 {
3189         int ret;
3190         struct printif *current_printif = get_printer_fns( snum );
3191
3192         if (!print_access_check(server_info, msg_ctx, snum,
3193                                 PRINTER_ACCESS_ADMINISTER)) {
3194                 return WERR_ACCESS_DENIED;
3195         }
3196
3197         become_root();
3198
3199         ret = (*(current_printif->queue_resume))(snum);
3200
3201         unbecome_root();
3202
3203         if (ret != 0) {
3204                 return WERR_INVALID_PARAM;
3205         }
3206
3207         /* make sure the database is up to date */
3208         if (print_cache_expired(lp_const_servicename(snum), True))
3209                 print_queue_update(msg_ctx, snum, True);
3210
3211         /* Send a printer notify message */
3212
3213         notify_printer_status(server_event_context(), msg_ctx, snum,
3214                               PRINTER_STATUS_OK);
3215
3216         return WERR_OK;
3217 }
3218
3219 /****************************************************************************
3220  Purge a queue - implemented by deleting all jobs that we can delete.
3221 ****************************************************************************/
3222
3223 WERROR print_queue_purge(const struct auth_session_info *server_info,
3224                          struct messaging_context *msg_ctx, int snum)
3225 {
3226         print_queue_struct *queue;
3227         print_status_struct status;
3228         int njobs, i;
3229         bool can_job_admin;
3230
3231         /* Force and update so the count is accurate (i.e. not a cached count) */
3232         print_queue_update(msg_ctx, snum, True);
3233
3234         can_job_admin = print_access_check(server_info,
3235                                            msg_ctx,
3236                                            snum,
3237                                            JOB_ACCESS_ADMINISTER);
3238         njobs = print_queue_status(msg_ctx, snum, &queue, &status);
3239
3240         if ( can_job_admin )
3241                 become_root();
3242
3243         for (i=0;i<njobs;i++) {
3244                 bool owner = is_owner(server_info, lp_const_servicename(snum),
3245                                       queue[i].sysjob);
3246
3247                 if (owner || can_job_admin) {
3248                         print_job_delete1(server_event_context(), msg_ctx,
3249                                           snum, queue[i].sysjob);
3250                 }
3251         }
3252
3253         if ( can_job_admin )
3254                 unbecome_root();
3255
3256         /* update the cache */
3257         print_queue_update(msg_ctx, snum, True);
3258
3259         SAFE_FREE(queue);
3260
3261         return WERR_OK;
3262 }