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