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