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 static bool printer_housekeeping_fn(const struct timeval *now,
1660                                     void *private_data)
1661 {
1662         static time_t last_pcap_reload_time = 0;
1663         time_t printcap_cache_time = (time_t)lp_printcap_cache_time();
1664         time_t t = time_mono(NULL);
1665
1666         DEBUG(5, ("printer housekeeping\n"));
1667
1668         /* if periodic printcap rescan is enabled, see if it's time to reload */
1669         if ((printcap_cache_time != 0)
1670          && (t >= (last_pcap_reload_time + printcap_cache_time))) {
1671                 DEBUG( 3,( "Printcap cache time expired.\n"));
1672                 pcap_cache_reload(server_event_context(),
1673                                   smbd_messaging_context(),
1674                                   &reload_pcap_change_notify);
1675                 last_pcap_reload_time = t;
1676         }
1677
1678         return true;
1679 }
1680
1681 static pid_t background_lpq_updater_pid = -1;
1682
1683 /****************************************************************************
1684 main thread of the background lpq updater
1685 ****************************************************************************/
1686 void start_background_queue(struct tevent_context *ev,
1687                             struct messaging_context *msg_ctx)
1688 {
1689         /* Use local variables for this as we don't
1690          * need to save the parent side of this, just
1691          * ensure it closes when the process exits.
1692          */
1693         int pause_pipe[2];
1694
1695         DEBUG(3,("start_background_queue: Starting background LPQ thread\n"));
1696
1697         if (pipe(pause_pipe) == -1) {
1698                 DEBUG(5,("start_background_queue: cannot create pipe. %s\n", strerror(errno) ));
1699                 exit(1);
1700         }
1701
1702         background_lpq_updater_pid = sys_fork();
1703
1704         if (background_lpq_updater_pid == -1) {
1705                 DEBUG(5,("start_background_queue: background LPQ thread failed to start. %s\n", strerror(errno) ));
1706                 exit(1);
1707         }
1708
1709         /* Track the printing pid along with other smbd children */
1710         add_child_pid(background_lpq_updater_pid);
1711
1712         if(background_lpq_updater_pid == 0) {
1713                 struct tevent_fd *fde;
1714                 int ret;
1715                 NTSTATUS status;
1716
1717                 /* Child. */
1718                 DEBUG(5,("start_background_queue: background LPQ thread started\n"));
1719
1720                 close(pause_pipe[0]);
1721                 pause_pipe[0] = -1;
1722
1723                 status = reinit_after_fork(msg_ctx, ev, procid_self(), true);
1724
1725                 if (!NT_STATUS_IS_OK(status)) {
1726                         DEBUG(0,("reinit_after_fork() failed\n"));
1727                         smb_panic("reinit_after_fork() failed");
1728                 }
1729
1730                 smbd_setup_sig_term_handler();
1731                 smbd_setup_sig_hup_handler(ev, msg_ctx);
1732
1733                 if (!serverid_register(procid_self(),
1734                                        FLAG_MSG_GENERAL|FLAG_MSG_SMBD
1735                                        |FLAG_MSG_PRINT_GENERAL)) {
1736                         exit(1);
1737                 }
1738
1739                 if (!locking_init()) {
1740                         exit(1);
1741                 }
1742
1743                 messaging_register(msg_ctx, NULL, MSG_PRINTER_UPDATE,
1744                                    print_queue_receive);
1745
1746                 fde = tevent_add_fd(ev, ev, pause_pipe[1], TEVENT_FD_READ,
1747                                     printing_pause_fd_handler,
1748                                     NULL);
1749                 if (!fde) {
1750                         DEBUG(0,("tevent_add_fd() failed for pause_pipe\n"));
1751                         smb_panic("tevent_add_fd() failed for pause_pipe");
1752                 }
1753
1754                 if (!(event_add_idle(ev, NULL,
1755                                      timeval_set(SMBD_HOUSEKEEPING_INTERVAL, 0),
1756                                      "printer_housekeeping",
1757                                      printer_housekeeping_fn,
1758                                      NULL))) {
1759                         DEBUG(0, ("Could not add printing housekeeping event\n"));
1760                         exit(1);
1761                 }
1762
1763                 DEBUG(5,("start_background_queue: background LPQ thread waiting for messages\n"));
1764                 ret = tevent_loop_wait(ev);
1765                 /* should not be reached */
1766                 DEBUG(0,("background_queue: tevent_loop_wait() exited with %d - %s\n",
1767                          ret, (ret == 0) ? "out of events" : strerror(errno)));
1768                 exit(1);
1769         }
1770
1771         close(pause_pipe[1]);
1772 }
1773
1774 /****************************************************************************
1775 update the internal database from the system print queue for a queue
1776 ****************************************************************************/
1777
1778 static void print_queue_update(struct messaging_context *msg_ctx,
1779                                int snum, bool force)
1780 {
1781         fstring key;
1782         fstring sharename;
1783         char *lpqcommand = NULL;
1784         char *lprmcommand = NULL;
1785         uint8 *buffer = NULL;
1786         size_t len = 0;
1787         size_t newlen;
1788         struct tdb_print_db *pdb;
1789         int type;
1790         struct printif *current_printif;
1791         TALLOC_CTX *ctx = talloc_tos();
1792
1793         fstrcpy( sharename, lp_const_servicename(snum));
1794
1795         /* don't strip out characters like '$' from the printername */
1796
1797         lpqcommand = talloc_string_sub2(ctx,
1798                         lp_lpqcommand(snum),
1799                         "%p",
1800                         lp_printername(snum),
1801                         false, false, false);
1802         if (!lpqcommand) {
1803                 return;
1804         }
1805         lpqcommand = talloc_sub_advanced(ctx,
1806                         lp_servicename(snum),
1807                         current_user_info.unix_name,
1808                         "",
1809                         current_user.ut.gid,
1810                         get_current_username(),
1811                         current_user_info.domain,
1812                         lpqcommand);
1813         if (!lpqcommand) {
1814                 return;
1815         }
1816
1817         lprmcommand = talloc_string_sub2(ctx,
1818                         lp_lprmcommand(snum),
1819                         "%p",
1820                         lp_printername(snum),
1821                         false, false, false);
1822         if (!lprmcommand) {
1823                 return;
1824         }
1825         lprmcommand = talloc_sub_advanced(ctx,
1826                         lp_servicename(snum),
1827                         current_user_info.unix_name,
1828                         "",
1829                         current_user.ut.gid,
1830                         get_current_username(),
1831                         current_user_info.domain,
1832                         lprmcommand);
1833         if (!lprmcommand) {
1834                 return;
1835         }
1836
1837         /*
1838          * Make sure that the background queue process exists.
1839          * Otherwise just do the update ourselves
1840          */
1841
1842         if ( force || background_lpq_updater_pid == -1 ) {
1843                 DEBUG(4,("print_queue_update: updating queue [%s] myself\n", sharename));
1844                 current_printif = get_printer_fns( snum );
1845                 print_queue_update_with_lock(server_event_context(), msg_ctx,
1846                                              sharename, current_printif,
1847                                              lpqcommand, lprmcommand);
1848
1849                 return;
1850         }
1851
1852         type = lp_printing(snum);
1853
1854         /* get the length */
1855
1856         len = tdb_pack( NULL, 0, "fdPP",
1857                 sharename,
1858                 type,
1859                 lpqcommand,
1860                 lprmcommand );
1861
1862         buffer = SMB_XMALLOC_ARRAY( uint8, len );
1863
1864         /* now pack the buffer */
1865         newlen = tdb_pack( buffer, len, "fdPP",
1866                 sharename,
1867                 type,
1868                 lpqcommand,
1869                 lprmcommand );
1870
1871         SMB_ASSERT( newlen == len );
1872
1873         DEBUG(10,("print_queue_update: Sending message -> printer = %s, "
1874                 "type = %d, lpq command = [%s] lprm command = [%s]\n",
1875                 sharename, type, lpqcommand, lprmcommand ));
1876
1877         /* here we set a msg pending record for other smbd processes
1878            to throttle the number of duplicate print_queue_update msgs
1879            sent.  */
1880
1881         pdb = get_print_db_byname(sharename);
1882         if (!pdb) {
1883                 SAFE_FREE(buffer);
1884                 return;
1885         }
1886
1887         snprintf(key, sizeof(key), "MSG_PENDING/%s", sharename);
1888
1889         if ( !tdb_store_uint32( pdb->tdb, key, time(NULL) ) ) {
1890                 /* log a message but continue on */
1891
1892                 DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n",
1893                         sharename));
1894         }
1895
1896         release_print_db( pdb );
1897
1898         /* finally send the message */
1899
1900         messaging_send_buf(msg_ctx, pid_to_procid(background_lpq_updater_pid),
1901                            MSG_PRINTER_UPDATE, (uint8 *)buffer, len);
1902
1903         SAFE_FREE( buffer );
1904
1905         return;
1906 }
1907
1908 /****************************************************************************
1909  Create/Update an entry in the print tdb that will allow us to send notify
1910  updates only to interested smbd's.
1911 ****************************************************************************/
1912
1913 bool print_notify_register_pid(int snum)
1914 {
1915         TDB_DATA data;
1916         struct tdb_print_db *pdb = NULL;
1917         TDB_CONTEXT *tdb = NULL;
1918         const char *printername;
1919         uint32 mypid = (uint32)sys_getpid();
1920         bool ret = False;
1921         size_t i;
1922
1923         /* if (snum == -1), then the change notify request was
1924            on a print server handle and we need to register on
1925            all print queus */
1926
1927         if (snum == -1)
1928         {
1929                 int num_services = lp_numservices();
1930                 int idx;
1931
1932                 for ( idx=0; idx<num_services; idx++ ) {
1933                         if (lp_snum_ok(idx) && lp_print_ok(idx) )
1934                                 print_notify_register_pid(idx);
1935                 }
1936
1937                 return True;
1938         }
1939         else /* register for a specific printer */
1940         {
1941                 printername = lp_const_servicename(snum);
1942                 pdb = get_print_db_byname(printername);
1943                 if (!pdb)
1944                         return False;
1945                 tdb = pdb->tdb;
1946         }
1947
1948         if (tdb_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) == -1) {
1949                 DEBUG(0,("print_notify_register_pid: Failed to lock printer %s\n",
1950                                         printername));
1951                 if (pdb)
1952                         release_print_db(pdb);
1953                 return False;
1954         }
1955
1956         data = get_printer_notify_pid_list( tdb, printername, True );
1957
1958         /* Add ourselves and increase the refcount. */
1959
1960         for (i = 0; i < data.dsize; i += 8) {
1961                 if (IVAL(data.dptr,i) == mypid) {
1962                         uint32 new_refcount = IVAL(data.dptr, i+4) + 1;
1963                         SIVAL(data.dptr, i+4, new_refcount);
1964                         break;
1965                 }
1966         }
1967
1968         if (i == data.dsize) {
1969                 /* We weren't in the list. Realloc. */
1970                 data.dptr = (uint8 *)SMB_REALLOC(data.dptr, data.dsize + 8);
1971                 if (!data.dptr) {
1972                         DEBUG(0,("print_notify_register_pid: Relloc fail for printer %s\n",
1973                                                 printername));
1974                         goto done;
1975                 }
1976                 data.dsize += 8;
1977                 SIVAL(data.dptr,data.dsize - 8,mypid);
1978                 SIVAL(data.dptr,data.dsize - 4,1); /* Refcount. */
1979         }
1980
1981         /* Store back the record. */
1982         if (tdb_store_bystring(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) == -1) {
1983                 DEBUG(0,("print_notify_register_pid: Failed to update pid \
1984 list for printer %s\n", printername));
1985                 goto done;
1986         }
1987
1988         ret = True;
1989
1990  done:
1991
1992         tdb_unlock_bystring(tdb, NOTIFY_PID_LIST_KEY);
1993         if (pdb)
1994                 release_print_db(pdb);
1995         SAFE_FREE(data.dptr);
1996         return ret;
1997 }
1998
1999 /****************************************************************************
2000  Update an entry in the print tdb that will allow us to send notify
2001  updates only to interested smbd's.
2002 ****************************************************************************/
2003
2004 bool print_notify_deregister_pid(int snum)
2005 {
2006         TDB_DATA data;
2007         struct tdb_print_db *pdb = NULL;
2008         TDB_CONTEXT *tdb = NULL;
2009         const char *printername;
2010         uint32 mypid = (uint32)sys_getpid();
2011         size_t i;
2012         bool ret = False;
2013
2014         /* if ( snum == -1 ), we are deregister a print server handle
2015            which means to deregister on all print queues */
2016
2017         if (snum == -1)
2018         {
2019                 int num_services = lp_numservices();
2020                 int idx;
2021
2022                 for ( idx=0; idx<num_services; idx++ ) {
2023                         if ( lp_snum_ok(idx) && lp_print_ok(idx) )
2024                                 print_notify_deregister_pid(idx);
2025                 }
2026
2027                 return True;
2028         }
2029         else /* deregister a specific printer */
2030         {
2031                 printername = lp_const_servicename(snum);
2032                 pdb = get_print_db_byname(printername);
2033                 if (!pdb)
2034                         return False;
2035                 tdb = pdb->tdb;
2036         }
2037
2038         if (tdb_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) == -1) {
2039                 DEBUG(0,("print_notify_register_pid: Failed to lock \
2040 printer %s database\n", printername));
2041                 if (pdb)
2042                         release_print_db(pdb);
2043                 return False;
2044         }
2045
2046         data = get_printer_notify_pid_list( tdb, printername, True );
2047
2048         /* Reduce refcount. Remove ourselves if zero. */
2049
2050         for (i = 0; i < data.dsize; ) {
2051                 if (IVAL(data.dptr,i) == mypid) {
2052                         uint32 refcount = IVAL(data.dptr, i+4);
2053
2054                         refcount--;
2055
2056                         if (refcount == 0) {
2057                                 if (data.dsize - i > 8)
2058                                         memmove( &data.dptr[i], &data.dptr[i+8], data.dsize - i - 8);
2059                                 data.dsize -= 8;
2060                                 continue;
2061                         }
2062                         SIVAL(data.dptr, i+4, refcount);
2063                 }
2064
2065                 i += 8;
2066         }
2067
2068         if (data.dsize == 0)
2069                 SAFE_FREE(data.dptr);
2070
2071         /* Store back the record. */
2072         if (tdb_store_bystring(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) == -1) {
2073                 DEBUG(0,("print_notify_register_pid: Failed to update pid \
2074 list for printer %s\n", printername));
2075                 goto done;
2076         }
2077
2078         ret = True;
2079
2080   done:
2081
2082         tdb_unlock_bystring(tdb, NOTIFY_PID_LIST_KEY);
2083         if (pdb)
2084                 release_print_db(pdb);
2085         SAFE_FREE(data.dptr);
2086         return ret;
2087 }
2088
2089 /****************************************************************************
2090  Check if a jobid is valid. It is valid if it exists in the database.
2091 ****************************************************************************/
2092
2093 bool print_job_exists(const char* sharename, uint32 jobid)
2094 {
2095         struct tdb_print_db *pdb = get_print_db_byname(sharename);
2096         bool ret;
2097         uint32_t tmp;
2098
2099         if (!pdb)
2100                 return False;
2101         ret = tdb_exists(pdb->tdb, print_key(jobid, &tmp));
2102         release_print_db(pdb);
2103         return ret;
2104 }
2105
2106 /****************************************************************************
2107  Return the device mode asigned to a specific print job.
2108  Only valid for the process doing the spooling and when the job
2109  has not been spooled.
2110 ****************************************************************************/
2111
2112 struct spoolss_DeviceMode *print_job_devmode(TALLOC_CTX *mem_ctx,
2113                                              const char *sharename,
2114                                              uint32 jobid)
2115 {
2116         struct printjob *pjob = print_job_find(mem_ctx, sharename, jobid);
2117         if (pjob == NULL) {
2118                 return NULL;
2119         }
2120
2121         return pjob->devmode;
2122 }
2123
2124 /****************************************************************************
2125  Set the name of a job. Only possible for owner.
2126 ****************************************************************************/
2127
2128 bool print_job_set_name(struct tevent_context *ev,
2129                         struct messaging_context *msg_ctx,
2130                         const char *sharename, uint32 jobid, const char *name)
2131 {
2132         struct printjob *pjob;
2133         bool ret;
2134         TALLOC_CTX *tmp_ctx = talloc_new(ev);
2135         if (tmp_ctx == NULL) {
2136                 return false;
2137         }
2138
2139         pjob = print_job_find(tmp_ctx, sharename, jobid);
2140         if (!pjob || pjob->pid != sys_getpid()) {
2141                 ret = false;
2142                 goto err_out;
2143         }
2144
2145         fstrcpy(pjob->jobname, name);
2146         ret = pjob_store(ev, msg_ctx, sharename, jobid, pjob);
2147 err_out:
2148         talloc_free(tmp_ctx);
2149         return ret;
2150 }
2151
2152 /****************************************************************************
2153  Get the name of a job. Only possible for owner.
2154 ****************************************************************************/
2155
2156 bool print_job_get_name(TALLOC_CTX *mem_ctx, const char *sharename, uint32_t jobid, char **name)
2157 {
2158         struct printjob *pjob;
2159
2160         pjob = print_job_find(mem_ctx, sharename, jobid);
2161         if (!pjob || pjob->pid != sys_getpid()) {
2162                 return false;
2163         }
2164
2165         *name = pjob->jobname;
2166         return true;
2167 }
2168
2169
2170 /***************************************************************************
2171  Remove a jobid from the 'jobs added' list.
2172 ***************************************************************************/
2173
2174 static bool remove_from_jobs_added(const char* sharename, uint32 jobid)
2175 {
2176         struct tdb_print_db *pdb = get_print_db_byname(sharename);
2177         TDB_DATA data, key;
2178         size_t job_count, i;
2179         bool ret = False;
2180         bool gotlock = False;
2181
2182         if (!pdb) {
2183                 return False;
2184         }
2185
2186         ZERO_STRUCT(data);
2187
2188         key = string_tdb_data("INFO/jobs_added");
2189
2190         if (tdb_chainlock_with_timeout(pdb->tdb, key, 5) == -1)
2191                 goto out;
2192
2193         gotlock = True;
2194
2195         data = tdb_fetch(pdb->tdb, key);
2196
2197         if (data.dptr == NULL || data.dsize == 0 || (data.dsize % 4 != 0))
2198                 goto out;
2199
2200         job_count = data.dsize / 4;
2201         for (i = 0; i < job_count; i++) {
2202                 uint32 ch_jobid;
2203
2204                 ch_jobid = IVAL(data.dptr, i*4);
2205                 if (ch_jobid == jobid) {
2206                         if (i < job_count -1 )
2207                                 memmove(data.dptr + (i*4), data.dptr + (i*4) + 4, (job_count - i - 1)*4 );
2208                         data.dsize -= 4;
2209                         if (tdb_store(pdb->tdb, key, data, TDB_REPLACE) == -1)
2210                                 goto out;
2211                         break;
2212                 }
2213         }
2214
2215         ret = True;
2216   out:
2217
2218         if (gotlock)
2219                 tdb_chainunlock(pdb->tdb, key);
2220         SAFE_FREE(data.dptr);
2221         release_print_db(pdb);
2222         if (ret)
2223                 DEBUG(10,("remove_from_jobs_added: removed jobid %u\n", (unsigned int)jobid ));
2224         else
2225                 DEBUG(10,("remove_from_jobs_added: Failed to remove jobid %u\n", (unsigned int)jobid ));
2226         return ret;
2227 }
2228
2229 /****************************************************************************
2230  Delete a print job - don't update queue.
2231 ****************************************************************************/
2232
2233 static bool print_job_delete1(struct tevent_context *ev,
2234                               struct messaging_context *msg_ctx,
2235                               int snum, uint32 jobid)
2236 {
2237         const char* sharename = lp_const_servicename(snum);
2238         struct printjob *pjob;
2239         int result = 0;
2240         struct printif *current_printif = get_printer_fns( snum );
2241         bool ret;
2242         TALLOC_CTX *tmp_ctx = talloc_new(ev);
2243         if (tmp_ctx == NULL) {
2244                 return false;
2245         }
2246
2247         pjob = print_job_find(tmp_ctx, sharename, jobid);
2248         if (!pjob) {
2249                 ret = false;
2250                 goto err_out;
2251         }
2252
2253         /*
2254          * If already deleting just return.
2255          */
2256
2257         if (pjob->status == LPQ_DELETING) {
2258                 ret = true;
2259                 goto err_out;
2260         }
2261
2262         /* Hrm - we need to be able to cope with deleting a job before it
2263            has reached the spooler.  Just mark it as LPQ_DELETING and
2264            let the print_queue_update() code rmeove the record */
2265
2266
2267         if (pjob->sysjob == -1) {
2268                 DEBUG(5, ("attempt to delete job %u not seen by lpr\n", (unsigned int)jobid));
2269         }
2270
2271         /* Set the tdb entry to be deleting. */
2272
2273         pjob->status = LPQ_DELETING;
2274         pjob_store(ev, msg_ctx, sharename, jobid, pjob);
2275
2276         if (pjob->spooled && pjob->sysjob != -1)
2277         {
2278                 result = (*(current_printif->job_delete))(
2279                         lp_printername(snum),
2280                         lp_lprmcommand(snum),
2281                         pjob);
2282
2283                 /* Delete the tdb entry if the delete succeeded or the job hasn't
2284                    been spooled. */
2285
2286                 if (result == 0) {
2287                         struct tdb_print_db *pdb = get_print_db_byname(sharename);
2288                         int njobs = 1;
2289
2290                         if (!pdb) {
2291                                 ret = false;
2292                                 goto err_out;
2293                         }
2294                         pjob_delete(ev, msg_ctx, sharename, jobid);
2295                         /* Ensure we keep a rough count of the number of total jobs... */
2296                         tdb_change_int32_atomic(pdb->tdb, "INFO/total_jobs", &njobs, -1);
2297                         release_print_db(pdb);
2298                 }
2299         }
2300
2301         remove_from_jobs_added( sharename, jobid );
2302
2303         ret = (result == 0);
2304 err_out:
2305         talloc_free(tmp_ctx);
2306         return ret;
2307 }
2308
2309 /****************************************************************************
2310  Return true if the current user owns the print job.
2311 ****************************************************************************/
2312
2313 static bool is_owner(const struct auth_serversupplied_info *server_info,
2314                      const char *servicename,
2315                      uint32 jobid)
2316 {
2317         struct printjob *pjob;
2318         bool ret;
2319         TALLOC_CTX *tmp_ctx = talloc_new(server_info);
2320         if (tmp_ctx == NULL) {
2321                 return false;
2322         }
2323
2324         pjob = print_job_find(tmp_ctx, servicename, jobid);
2325         if (!pjob || !server_info) {
2326                 ret = false;
2327                 goto err_out;
2328         }
2329
2330         ret = strequal(pjob->user, server_info->sanitized_username);
2331 err_out:
2332         talloc_free(tmp_ctx);
2333         return ret;
2334 }
2335
2336 /****************************************************************************
2337  Delete a print job.
2338 ****************************************************************************/
2339
2340 WERROR print_job_delete(const struct auth_serversupplied_info *server_info,
2341                         struct messaging_context *msg_ctx,
2342                         int snum, uint32_t jobid)
2343 {
2344         const char* sharename = lp_const_servicename(snum);
2345         struct printjob *pjob;
2346         bool    owner;
2347         WERROR werr;
2348         TALLOC_CTX *tmp_ctx = talloc_new(msg_ctx);
2349         if (tmp_ctx == NULL) {
2350                 return WERR_NOT_ENOUGH_MEMORY;
2351         }
2352
2353         owner = is_owner(server_info, lp_const_servicename(snum), jobid);
2354
2355         /* Check access against security descriptor or whether the user
2356            owns their job. */
2357
2358         if (!owner &&
2359             !print_access_check(server_info, msg_ctx, snum,
2360                                 JOB_ACCESS_ADMINISTER)) {
2361                 DEBUG(3, ("delete denied by security descriptor\n"));
2362
2363                 /* BEGIN_ADMIN_LOG */
2364                 sys_adminlog( LOG_ERR,
2365                               "Permission denied-- user not allowed to delete, \
2366 pause, or resume print job. User name: %s. Printer name: %s.",
2367                               uidtoname(server_info->utok.uid),
2368                               lp_printername(snum) );
2369                 /* END_ADMIN_LOG */
2370
2371                 werr = WERR_ACCESS_DENIED;
2372                 goto err_out;
2373         }
2374
2375         /*
2376          * get the spooled filename of the print job
2377          * if this works, then the file has not been spooled
2378          * to the underlying print system.  Just delete the
2379          * spool file & return.
2380          */
2381
2382         pjob = print_job_find(tmp_ctx, sharename, jobid);
2383         if (!pjob || pjob->spooled || pjob->pid != getpid()) {
2384                 DEBUG(10, ("Skipping spool file removal for job %u\n", jobid));
2385         } else {
2386                 DEBUG(10, ("Removing spool file [%s]\n", pjob->filename));
2387                 if (unlink(pjob->filename) == -1) {
2388                         werr = map_werror_from_unix(errno);
2389                         goto err_out;
2390                 }
2391         }
2392
2393         if (!print_job_delete1(server_event_context(), msg_ctx, snum, jobid)) {
2394                 werr = WERR_ACCESS_DENIED;
2395                 goto err_out;
2396         }
2397
2398         /* force update the database and say the delete failed if the
2399            job still exists */
2400
2401         print_queue_update(msg_ctx, snum, True);
2402
2403         pjob = print_job_find(tmp_ctx, sharename, jobid);
2404         if (pjob && (pjob->status != LPQ_DELETING)) {
2405                 werr = WERR_ACCESS_DENIED;
2406                 goto err_out;
2407         }
2408         werr = WERR_PRINTER_HAS_JOBS_QUEUED;
2409
2410 err_out:
2411         talloc_free(tmp_ctx);
2412         return werr;
2413 }
2414
2415 /****************************************************************************
2416  Pause a job.
2417 ****************************************************************************/
2418
2419 WERROR print_job_pause(const struct auth_serversupplied_info *server_info,
2420                      struct messaging_context *msg_ctx,
2421                      int snum, uint32 jobid)
2422 {
2423         const char* sharename = lp_const_servicename(snum);
2424         struct printjob *pjob;
2425         int ret = -1;
2426         struct printif *current_printif = get_printer_fns( snum );
2427         WERROR werr;
2428         TALLOC_CTX *tmp_ctx = talloc_new(msg_ctx);
2429         if (tmp_ctx == NULL) {
2430                 return WERR_NOT_ENOUGH_MEMORY;
2431         }
2432
2433         pjob = print_job_find(tmp_ctx, sharename, jobid);
2434         if (!pjob || !server_info) {
2435                 DEBUG(10, ("print_job_pause: no pjob or user for jobid %u\n",
2436                         (unsigned int)jobid ));
2437                 werr = WERR_INVALID_PARAM;
2438                 goto err_out;
2439         }
2440
2441         if (!pjob->spooled || pjob->sysjob == -1) {
2442                 DEBUG(10, ("print_job_pause: not spooled or bad sysjob = %d for jobid %u\n",
2443                         (int)pjob->sysjob, (unsigned int)jobid ));
2444                 werr = WERR_INVALID_PARAM;
2445                 goto err_out;
2446         }
2447
2448         if (!is_owner(server_info, lp_const_servicename(snum), jobid) &&
2449             !print_access_check(server_info, msg_ctx, snum,
2450                                 JOB_ACCESS_ADMINISTER)) {
2451                 DEBUG(3, ("pause denied by security descriptor\n"));
2452
2453                 /* BEGIN_ADMIN_LOG */
2454                 sys_adminlog( LOG_ERR,
2455                         "Permission denied-- user not allowed to delete, \
2456 pause, or resume print job. User name: %s. Printer name: %s.",
2457                               uidtoname(server_info->utok.uid),
2458                               lp_printername(snum) );
2459                 /* END_ADMIN_LOG */
2460
2461                 werr = WERR_ACCESS_DENIED;
2462                 goto err_out;
2463         }
2464
2465         /* need to pause the spooled entry */
2466         ret = (*(current_printif->job_pause))(snum, pjob);
2467
2468         if (ret != 0) {
2469                 werr = WERR_INVALID_PARAM;
2470                 goto err_out;
2471         }
2472
2473         /* force update the database */
2474         print_cache_flush(lp_const_servicename(snum));
2475
2476         /* Send a printer notify message */
2477
2478         notify_job_status(server_event_context(), msg_ctx, sharename, jobid,
2479                           JOB_STATUS_PAUSED);
2480
2481         /* how do we tell if this succeeded? */
2482         werr = WERR_OK;
2483 err_out:
2484         talloc_free(tmp_ctx);
2485         return werr;
2486 }
2487
2488 /****************************************************************************
2489  Resume a job.
2490 ****************************************************************************/
2491
2492 WERROR print_job_resume(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;
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         pjob = print_job_find(tmp_ctx, sharename, jobid);
2506         if (!pjob || !server_info) {
2507                 DEBUG(10, ("print_job_resume: no pjob or user for jobid %u\n",
2508                         (unsigned int)jobid ));
2509                 werr = WERR_INVALID_PARAM;
2510                 goto err_out;
2511         }
2512
2513         if (!pjob->spooled || pjob->sysjob == -1) {
2514                 DEBUG(10, ("print_job_resume: not spooled or bad sysjob = %d for jobid %u\n",
2515                         (int)pjob->sysjob, (unsigned int)jobid ));
2516                 werr = WERR_INVALID_PARAM;
2517                 goto err_out;
2518         }
2519
2520         if (!is_owner(server_info, lp_const_servicename(snum), jobid) &&
2521             !print_access_check(server_info, msg_ctx, snum,
2522                                 JOB_ACCESS_ADMINISTER)) {
2523                 DEBUG(3, ("resume denied by security descriptor\n"));
2524
2525                 /* BEGIN_ADMIN_LOG */
2526                 sys_adminlog( LOG_ERR,
2527                          "Permission denied-- user not allowed to delete, \
2528 pause, or resume print job. User name: %s. Printer name: %s.",
2529                               uidtoname(server_info->utok.uid),
2530                               lp_printername(snum) );
2531                 /* END_ADMIN_LOG */
2532                 werr = WERR_ACCESS_DENIED;
2533                 goto err_out;
2534         }
2535
2536         ret = (*(current_printif->job_resume))(snum, pjob);
2537
2538         if (ret != 0) {
2539                 werr = WERR_INVALID_PARAM;
2540                 goto err_out;
2541         }
2542
2543         /* force update the database */
2544         print_cache_flush(lp_const_servicename(snum));
2545
2546         /* Send a printer notify message */
2547
2548         notify_job_status(server_event_context(), msg_ctx, sharename, jobid,
2549                           JOB_STATUS_QUEUED);
2550
2551         werr = WERR_OK;
2552 err_out:
2553         talloc_free(tmp_ctx);
2554         return werr;
2555 }
2556
2557 /****************************************************************************
2558  Write to a print file.
2559 ****************************************************************************/
2560
2561 ssize_t print_job_write(struct tevent_context *ev,
2562                         struct messaging_context *msg_ctx,
2563                         int snum, uint32 jobid, const char *buf, size_t size)
2564 {
2565         const char* sharename = lp_const_servicename(snum);
2566         ssize_t return_code;
2567         struct printjob *pjob;
2568         TALLOC_CTX *tmp_ctx = talloc_new(ev);
2569         if (tmp_ctx == NULL) {
2570                 return -1;
2571         }
2572
2573         pjob = print_job_find(tmp_ctx, sharename, jobid);
2574         if (!pjob) {
2575                 return_code = -1;
2576                 goto err_out;
2577         }
2578
2579         /* don't allow another process to get this info - it is meaningless */
2580         if (pjob->pid != sys_getpid()) {
2581                 return_code = -1;
2582                 goto err_out;
2583         }
2584
2585         /* if SMBD is spooling this can't be allowed */
2586         if (pjob->status == PJOB_SMBD_SPOOLING) {
2587                 return_code = -1;
2588                 goto err_out;
2589         }
2590
2591         return_code = write_data(pjob->fd, buf, size);
2592         if (return_code > 0) {
2593                 pjob->size += size;
2594                 pjob_store(ev, msg_ctx, sharename, jobid, pjob);
2595         }
2596 err_out:
2597         talloc_free(tmp_ctx);
2598         return return_code;
2599 }
2600
2601 /****************************************************************************
2602  Get the queue status - do not update if db is out of date.
2603 ****************************************************************************/
2604
2605 static int get_queue_status(const char* sharename, print_status_struct *status)
2606 {
2607         fstring keystr;
2608         TDB_DATA data;
2609         struct tdb_print_db *pdb = get_print_db_byname(sharename);
2610         int len;
2611
2612         if (status) {
2613                 ZERO_STRUCTP(status);
2614         }
2615
2616         if (!pdb)
2617                 return 0;
2618
2619         if (status) {
2620                 fstr_sprintf(keystr, "STATUS/%s", sharename);
2621                 data = tdb_fetch(pdb->tdb, string_tdb_data(keystr));
2622                 if (data.dptr) {
2623                         if (data.dsize == sizeof(print_status_struct))
2624                                 /* this memcpy is ok since the status struct was
2625                                    not packed before storing it in the tdb */
2626                                 memcpy(status, data.dptr, sizeof(print_status_struct));
2627                         SAFE_FREE(data.dptr);
2628                 }
2629         }
2630         len = tdb_fetch_int32(pdb->tdb, "INFO/total_jobs");
2631         release_print_db(pdb);
2632         return (len == -1 ? 0 : len);
2633 }
2634
2635 /****************************************************************************
2636  Determine the number of jobs in a queue.
2637 ****************************************************************************/
2638
2639 int print_queue_length(struct messaging_context *msg_ctx, int snum,
2640                        print_status_struct *pstatus)
2641 {
2642         const char* sharename = lp_const_servicename( snum );
2643         print_status_struct status;
2644         int len;
2645
2646         ZERO_STRUCT( status );
2647
2648         /* make sure the database is up to date */
2649         if (print_cache_expired(lp_const_servicename(snum), True))
2650                 print_queue_update(msg_ctx, snum, False);
2651
2652         /* also fetch the queue status */
2653         memset(&status, 0, sizeof(status));
2654         len = get_queue_status(sharename, &status);
2655
2656         if (pstatus)
2657                 *pstatus = status;
2658
2659         return len;
2660 }
2661
2662 /***************************************************************************
2663  Allocate a jobid. Hold the lock for as short a time as possible.
2664 ***************************************************************************/
2665
2666 static WERROR allocate_print_jobid(struct tdb_print_db *pdb, int snum,
2667                                    const char *sharename, uint32 *pjobid)
2668 {
2669         int i;
2670         uint32 jobid;
2671         enum TDB_ERROR terr;
2672         int ret;
2673
2674         *pjobid = (uint32)-1;
2675
2676         for (i = 0; i < 3; i++) {
2677                 /* Lock the database - only wait 20 seconds. */
2678                 ret = tdb_lock_bystring_with_timeout(pdb->tdb,
2679                                                      "INFO/nextjob", 20);
2680                 if (ret == -1) {
2681                         DEBUG(0, ("allocate_print_jobid: "
2682                                   "Failed to lock printing database %s\n",
2683                                   sharename));
2684                         terr = tdb_error(pdb->tdb);
2685                         return ntstatus_to_werror(map_nt_error_from_tdb(terr));
2686                 }
2687
2688                 if (!tdb_fetch_uint32(pdb->tdb, "INFO/nextjob", &jobid)) {
2689                         terr = tdb_error(pdb->tdb);
2690                         if (terr != TDB_ERR_NOEXIST) {
2691                                 DEBUG(0, ("allocate_print_jobid: "
2692                                           "Failed to fetch INFO/nextjob "
2693                                           "for print queue %s\n", sharename));
2694                                 tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
2695                                 return ntstatus_to_werror(map_nt_error_from_tdb(terr));
2696                         }
2697                         DEBUG(10, ("allocate_print_jobid: "
2698                                    "No existing jobid in %s\n", sharename));
2699                         jobid = 0;
2700                 }
2701
2702                 DEBUG(10, ("allocate_print_jobid: "
2703                            "Read jobid %u from %s\n", jobid, sharename));
2704
2705                 jobid = NEXT_JOBID(jobid);
2706
2707                 ret = tdb_store_int32(pdb->tdb, "INFO/nextjob", jobid);
2708                 if (ret == -1) {
2709                         terr = tdb_error(pdb->tdb);
2710                         DEBUG(3, ("allocate_print_jobid: "
2711                                   "Failed to store INFO/nextjob.\n"));
2712                         tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
2713                         return ntstatus_to_werror(map_nt_error_from_tdb(terr));
2714                 }
2715
2716                 /* We've finished with the INFO/nextjob lock. */
2717                 tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
2718
2719                 if (!print_job_exists(sharename, jobid)) {
2720                         break;
2721                 }
2722                 DEBUG(10, ("allocate_print_jobid: "
2723                            "Found jobid %u in %s\n", jobid, sharename));
2724         }
2725
2726         if (i > 2) {
2727                 DEBUG(0, ("allocate_print_jobid: "
2728                           "Failed to allocate a print job for queue %s\n",
2729                           sharename));
2730                 /* Probably full... */
2731                 return WERR_NO_SPOOL_SPACE;
2732         }
2733
2734         /* Store a dummy placeholder. */
2735         {
2736                 uint32_t tmp;
2737                 TDB_DATA dum;
2738                 dum.dptr = NULL;
2739                 dum.dsize = 0;
2740                 if (tdb_store(pdb->tdb, print_key(jobid, &tmp), dum,
2741                               TDB_INSERT) == -1) {
2742                         DEBUG(3, ("allocate_print_jobid: "
2743                                   "jobid (%d) failed to store placeholder.\n",
2744                                   jobid ));
2745                         terr = tdb_error(pdb->tdb);
2746                         return ntstatus_to_werror(map_nt_error_from_tdb(terr));
2747                 }
2748         }
2749
2750         *pjobid = jobid;
2751         return WERR_OK;
2752 }
2753
2754 /***************************************************************************
2755  Append a jobid to the 'jobs added' list.
2756 ***************************************************************************/
2757
2758 static bool add_to_jobs_added(struct tdb_print_db *pdb, uint32 jobid)
2759 {
2760         TDB_DATA data;
2761         uint32 store_jobid;
2762
2763         SIVAL(&store_jobid, 0, jobid);
2764         data.dptr = (uint8 *)&store_jobid;
2765         data.dsize = 4;
2766
2767         DEBUG(10,("add_to_jobs_added: Added jobid %u\n", (unsigned int)jobid ));
2768
2769         return (tdb_append(pdb->tdb, string_tdb_data("INFO/jobs_added"),
2770                            data) == 0);
2771 }
2772
2773
2774 /***************************************************************************
2775  Do all checks needed to determine if we can start a job.
2776 ***************************************************************************/
2777
2778 static WERROR print_job_checks(const struct auth_serversupplied_info *server_info,
2779                                struct messaging_context *msg_ctx,
2780                                int snum, int *njobs)
2781 {
2782         const char *sharename = lp_const_servicename(snum);
2783         uint64_t dspace, dsize;
2784         uint64_t minspace;
2785         int ret;
2786
2787         if (!print_access_check(server_info, msg_ctx, snum,
2788                                 PRINTER_ACCESS_USE)) {
2789                 DEBUG(3, ("print_job_checks: "
2790                           "job start denied by security descriptor\n"));
2791                 return WERR_ACCESS_DENIED;
2792         }
2793
2794         if (!print_time_access_check(server_info, msg_ctx, sharename)) {
2795                 DEBUG(3, ("print_job_checks: "
2796                           "job start denied by time check\n"));
2797                 return WERR_ACCESS_DENIED;
2798         }
2799
2800         /* see if we have sufficient disk space */
2801         if (lp_minprintspace(snum)) {
2802                 minspace = lp_minprintspace(snum);
2803                 ret = sys_fsusage(lp_pathname(snum), &dspace, &dsize);
2804                 if (ret == 0 && dspace < 2*minspace) {
2805                         DEBUG(3, ("print_job_checks: "
2806                                   "disk space check failed.\n"));
2807                         return WERR_NO_SPOOL_SPACE;
2808                 }
2809         }
2810
2811         /* for autoloaded printers, check that the printcap entry still exists */
2812         if (lp_autoloaded(snum) && !pcap_printername_ok(sharename)) {
2813                 DEBUG(3, ("print_job_checks: printer name %s check failed.\n",
2814                           sharename));
2815                 return WERR_ACCESS_DENIED;
2816         }
2817
2818         /* Insure the maximum queue size is not violated */
2819         *njobs = print_queue_length(msg_ctx, snum, NULL);
2820         if (*njobs > lp_maxprintjobs(snum)) {
2821                 DEBUG(3, ("print_job_checks: Queue %s number of jobs (%d) "
2822                           "larger than max printjobs per queue (%d).\n",
2823                           sharename, *njobs, lp_maxprintjobs(snum)));
2824                 return WERR_NO_SPOOL_SPACE;
2825         }
2826
2827         return WERR_OK;
2828 }
2829
2830 /***************************************************************************
2831  Create a job file.
2832 ***************************************************************************/
2833
2834 static WERROR print_job_spool_file(int snum, uint32_t jobid,
2835                                    const char *output_file,
2836                                    struct printjob *pjob)
2837 {
2838         WERROR werr;
2839         SMB_STRUCT_STAT st;
2840         const char *path;
2841         int len;
2842
2843         /* if this file is within the printer path, it means that smbd
2844          * is spooling it and will pass us control when it is finished.
2845          * Verify that the file name is ok, within path, and it is
2846          * already already there */
2847         if (output_file) {
2848                 path = lp_pathname(snum);
2849                 len = strlen(path);
2850                 if (strncmp(output_file, path, len) == 0 &&
2851                     (output_file[len - 1] == '/' || output_file[len] == '/')) {
2852
2853                         /* verify path is not too long */
2854                         if (strlen(output_file) >= sizeof(pjob->filename)) {
2855                                 return WERR_INVALID_NAME;
2856                         }
2857
2858                         /* verify that the file exists */
2859                         if (sys_stat(output_file, &st, false) != 0) {
2860                                 return WERR_INVALID_NAME;
2861                         }
2862
2863                         fstrcpy(pjob->filename, output_file);
2864
2865                         DEBUG(3, ("print_job_spool_file:"
2866                                   "External spooling activated"));
2867
2868                         /* we do not open the file until spooling is done */
2869                         pjob->fd = -1;
2870                         pjob->status = PJOB_SMBD_SPOOLING;
2871
2872                         return WERR_OK;
2873                 }
2874         }
2875
2876         slprintf(pjob->filename, sizeof(pjob->filename)-1,
2877                  "%s/%sXXXXXX", lp_pathname(snum), PRINT_SPOOL_PREFIX);
2878         pjob->fd = mkstemp(pjob->filename);
2879
2880         if (pjob->fd == -1) {
2881                 werr = map_werror_from_unix(errno);
2882                 if (W_ERROR_EQUAL(werr, WERR_ACCESS_DENIED)) {
2883                         /* Common setup error, force a report. */
2884                         DEBUG(0, ("print_job_spool_file: "
2885                                   "insufficient permissions to open spool "
2886                                   "file %s.\n", pjob->filename));
2887                 } else {
2888                         /* Normal case, report at level 3 and above. */
2889                         DEBUG(3, ("print_job_spool_file: "
2890                                   "can't open spool file %s\n",
2891                                   pjob->filename));
2892                 }
2893                 return werr;
2894         }
2895
2896         return WERR_OK;
2897 }
2898
2899 /***************************************************************************
2900  Start spooling a job - return the jobid.
2901 ***************************************************************************/
2902
2903 WERROR print_job_start(const struct auth_serversupplied_info *server_info,
2904                        struct messaging_context *msg_ctx,
2905                        const char *clientmachine,
2906                        int snum, const char *docname, const char *filename,
2907                        struct spoolss_DeviceMode *devmode, uint32_t *_jobid)
2908 {
2909         uint32_t jobid;
2910         char *path;
2911         struct printjob pjob;
2912         const char *sharename = lp_const_servicename(snum);
2913         struct tdb_print_db *pdb = get_print_db_byname(sharename);
2914         int njobs;
2915         WERROR werr;
2916
2917         if (!pdb) {
2918                 return WERR_INTERNAL_DB_CORRUPTION;
2919         }
2920
2921         path = lp_pathname(snum);
2922
2923         werr = print_job_checks(server_info, msg_ctx, snum, &njobs);
2924         if (!W_ERROR_IS_OK(werr)) {
2925                 release_print_db(pdb);
2926                 return werr;
2927         }
2928
2929         DEBUG(10, ("print_job_start: "
2930                    "Queue %s number of jobs (%d), max printjobs = %d\n",
2931                    sharename, njobs, lp_maxprintjobs(snum)));
2932
2933         werr = allocate_print_jobid(pdb, snum, sharename, &jobid);
2934         if (!W_ERROR_IS_OK(werr)) {
2935                 goto fail;
2936         }
2937
2938         /* create the database entry */
2939
2940         ZERO_STRUCT(pjob);
2941
2942         pjob.pid = sys_getpid();
2943         pjob.jobid = jobid;
2944         pjob.sysjob = -1;
2945         pjob.fd = -1;
2946         pjob.starttime = time(NULL);
2947         pjob.status = LPQ_SPOOLING;
2948         pjob.size = 0;
2949         pjob.spooled = False;
2950         pjob.smbjob = True;
2951         pjob.devmode = devmode;
2952
2953         fstrcpy(pjob.jobname, docname);
2954
2955         fstrcpy(pjob.clientmachine, clientmachine);
2956
2957         fstrcpy(pjob.user, lp_printjob_username(snum));
2958         standard_sub_advanced(sharename, server_info->sanitized_username,
2959                               path, server_info->utok.gid,
2960                               server_info->sanitized_username,
2961                               server_info->info3->base.domain.string,
2962                               pjob.user, sizeof(pjob.user)-1);
2963         /* ensure NULL termination */
2964         pjob.user[sizeof(pjob.user)-1] = '\0';
2965
2966         fstrcpy(pjob.queuename, lp_const_servicename(snum));
2967
2968         /* we have a job entry - now create the spool file */
2969         werr = print_job_spool_file(snum, jobid, filename, &pjob);
2970         if (!W_ERROR_IS_OK(werr)) {
2971                 goto fail;
2972         }
2973
2974         pjob_store(server_event_context(), msg_ctx, sharename, jobid, &pjob);
2975
2976         /* Update the 'jobs added' entry used by print_queue_status. */
2977         add_to_jobs_added(pdb, jobid);
2978
2979         /* Ensure we keep a rough count of the number of total jobs... */
2980         tdb_change_int32_atomic(pdb->tdb, "INFO/total_jobs", &njobs, 1);
2981
2982         release_print_db(pdb);
2983
2984         *_jobid = jobid;
2985         return WERR_OK;
2986
2987 fail:
2988         if (jobid != -1) {
2989                 pjob_delete(server_event_context(), msg_ctx, sharename, jobid);
2990         }
2991
2992         release_print_db(pdb);
2993
2994         DEBUG(3, ("print_job_start: returning fail. "
2995                   "Error = %s\n", win_errstr(werr)));
2996         return werr;
2997 }
2998
2999 /****************************************************************************
3000  Update the number of pages spooled to jobid
3001 ****************************************************************************/
3002
3003 void print_job_endpage(struct messaging_context *msg_ctx,
3004                        int snum, uint32 jobid)
3005 {
3006         const char* sharename = lp_const_servicename(snum);
3007         struct printjob *pjob;
3008         TALLOC_CTX *tmp_ctx = talloc_new(msg_ctx);
3009         if (tmp_ctx == NULL) {
3010                 return;
3011         }
3012
3013         pjob = print_job_find(tmp_ctx, sharename, jobid);
3014         if (!pjob) {
3015                 goto err_out;
3016         }
3017         /* don't allow another process to get this info - it is meaningless */
3018         if (pjob->pid != sys_getpid()) {
3019                 goto err_out;
3020         }
3021
3022         pjob->page_count++;
3023         pjob_store(server_event_context(), msg_ctx, sharename, jobid, pjob);
3024 err_out:
3025         talloc_free(tmp_ctx);
3026 }
3027
3028 /****************************************************************************
3029  Print a file - called on closing the file. This spools the job.
3030  If normal close is false then we're tearing down the jobs - treat as an
3031  error.
3032 ****************************************************************************/
3033
3034 NTSTATUS print_job_end(struct messaging_context *msg_ctx, int snum,
3035                        uint32 jobid, enum file_close_type close_type)
3036 {
3037         const char* sharename = lp_const_servicename(snum);
3038         struct printjob *pjob;
3039         int ret;
3040         SMB_STRUCT_STAT sbuf;
3041         struct printif *current_printif = get_printer_fns(snum);
3042         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
3043         char *lpq_cmd;
3044         TALLOC_CTX *tmp_ctx = talloc_new(msg_ctx);
3045         if (tmp_ctx == NULL) {
3046                 return NT_STATUS_NO_MEMORY;
3047         }
3048
3049         pjob = print_job_find(tmp_ctx, sharename, jobid);
3050         if (!pjob) {
3051                 status = NT_STATUS_PRINT_CANCELLED;
3052                 goto err_out;
3053         }
3054
3055         if (pjob->spooled || pjob->pid != sys_getpid()) {
3056                 status = NT_STATUS_ACCESS_DENIED;
3057                 goto err_out;
3058         }
3059
3060         if (close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) {
3061                 if (pjob->status == PJOB_SMBD_SPOOLING) {
3062                         /* take over the file now, smbd is done */
3063                         if (sys_stat(pjob->filename, &sbuf, false) != 0) {
3064                                 status = map_nt_error_from_unix(errno);
3065                                 DEBUG(3, ("print_job_end: "
3066                                           "stat file failed for jobid %d\n",
3067                                           jobid));
3068                                 goto fail;
3069                         }
3070
3071                         pjob->status = LPQ_SPOOLING;
3072
3073                 } else {
3074
3075                         if ((sys_fstat(pjob->fd, &sbuf, false) != 0)) {
3076                                 status = map_nt_error_from_unix(errno);
3077                                 close(pjob->fd);
3078                                 DEBUG(3, ("print_job_end: "
3079                                           "stat file failed for jobid %d\n",
3080                                           jobid));
3081                                 goto fail;
3082                         }
3083
3084                         close(pjob->fd);
3085                 }
3086
3087                 pjob->size = sbuf.st_ex_size;
3088         } else {
3089
3090                 /*
3091                  * Not a normal close, something has gone wrong. Cleanup.
3092                  */
3093                 if (pjob->fd != -1) {
3094                         close(pjob->fd);
3095                 }
3096                 goto fail;
3097         }
3098
3099         /* Technically, this is not quite right. If the printer has a separator
3100          * page turned on, the NT spooler prints the separator page even if the
3101          * print job is 0 bytes. 010215 JRR */
3102         if (pjob->size == 0 || pjob->status == LPQ_DELETING) {
3103                 /* don't bother spooling empty files or something being deleted. */
3104                 DEBUG(5,("print_job_end: canceling spool of %s (%s)\n",
3105                         pjob->filename, pjob->size ? "deleted" : "zero length" ));
3106                 unlink(pjob->filename);
3107                 pjob_delete(server_event_context(), msg_ctx, sharename, jobid);
3108                 return NT_STATUS_OK;
3109         }
3110
3111         /* don't strip out characters like '$' from the printername */
3112         lpq_cmd = talloc_string_sub2(tmp_ctx,
3113                                      lp_lpqcommand(snum),
3114                                      "%p",
3115                                      lp_printername(snum),
3116                                      false, false, false);
3117         if (lpq_cmd == NULL) {
3118                 status = NT_STATUS_PRINT_CANCELLED;
3119                 goto fail;
3120         }
3121         lpq_cmd = talloc_sub_advanced(tmp_ctx,
3122                                       lp_servicename(snum),
3123                                       current_user_info.unix_name,
3124                                       "",
3125                                       current_user.ut.gid,
3126                                       get_current_username(),
3127                                       current_user_info.domain,
3128                                       lpq_cmd);
3129         if (lpq_cmd == NULL) {
3130                 status = NT_STATUS_PRINT_CANCELLED;
3131                 goto fail;
3132         }
3133
3134         ret = (*(current_printif->job_submit))(snum, pjob,
3135                                                current_printif->type, lpq_cmd);
3136         if (ret) {
3137                 status = NT_STATUS_PRINT_CANCELLED;
3138                 goto fail;
3139         }
3140
3141         /* The print job has been successfully handed over to the back-end */
3142
3143         pjob->spooled = True;
3144         pjob->status = LPQ_QUEUED;
3145         pjob_store(server_event_context(), msg_ctx, sharename, jobid, pjob);
3146
3147         /* make sure the database is up to date */
3148         if (print_cache_expired(lp_const_servicename(snum), True))
3149                 print_queue_update(msg_ctx, snum, False);
3150
3151         return NT_STATUS_OK;
3152
3153 fail:
3154
3155         /* The print job was not successfully started. Cleanup */
3156         /* Still need to add proper error return propagation! 010122:JRR */
3157         pjob->fd = -1;
3158         unlink(pjob->filename);
3159         pjob_delete(server_event_context(), msg_ctx, sharename, jobid);
3160 err_out:
3161         talloc_free(tmp_ctx);
3162         return status;
3163 }
3164
3165 /****************************************************************************
3166  Get a snapshot of jobs in the system without traversing.
3167 ****************************************************************************/
3168
3169 static bool get_stored_queue_info(struct messaging_context *msg_ctx,
3170                                   struct tdb_print_db *pdb, int snum,
3171                                   int *pcount, print_queue_struct **ppqueue)
3172 {
3173         TDB_DATA data, cgdata, jcdata;
3174         print_queue_struct *queue = NULL;
3175         uint32 qcount = 0;
3176         uint32 extra_count = 0;
3177         uint32_t changed_count = 0;
3178         int total_count = 0;
3179         size_t len = 0;
3180         uint32 i;
3181         int max_reported_jobs = lp_max_reported_jobs(snum);
3182         bool ret = False;
3183         const char* sharename = lp_servicename(snum);
3184         TALLOC_CTX *tmp_ctx = talloc_new(msg_ctx);
3185         if (tmp_ctx == NULL) {
3186                 return false;
3187         }
3188
3189         /* make sure the database is up to date */
3190         if (print_cache_expired(lp_const_servicename(snum), True))
3191                 print_queue_update(msg_ctx, snum, False);
3192
3193         *pcount = 0;
3194         *ppqueue = NULL;
3195
3196         ZERO_STRUCT(data);
3197         ZERO_STRUCT(cgdata);
3198
3199         /* Get the stored queue data. */
3200         data = tdb_fetch(pdb->tdb, string_tdb_data("INFO/linear_queue_array"));
3201
3202         if (data.dptr && data.dsize >= sizeof(qcount))
3203                 len += tdb_unpack(data.dptr + len, data.dsize - len, "d", &qcount);
3204
3205         /* Get the added jobs list. */
3206         cgdata = tdb_fetch(pdb->tdb, string_tdb_data("INFO/jobs_added"));
3207         if (cgdata.dptr != NULL && (cgdata.dsize % 4 == 0))
3208                 extra_count = cgdata.dsize/4;
3209
3210         /* Get the changed jobs list. */
3211         jcdata = tdb_fetch(pdb->tdb, string_tdb_data("INFO/jobs_changed"));
3212         if (jcdata.dptr != NULL && (jcdata.dsize % 4 == 0))
3213                 changed_count = jcdata.dsize / 4;
3214
3215         DEBUG(5,("get_stored_queue_info: qcount = %u, extra_count = %u\n", (unsigned int)qcount, (unsigned int)extra_count));
3216
3217         /* Allocate the queue size. */
3218         if (qcount == 0 && extra_count == 0)
3219                 goto out;
3220
3221         if ((queue = SMB_MALLOC_ARRAY(print_queue_struct, qcount + extra_count)) == NULL)
3222                 goto out;
3223
3224         /* Retrieve the linearised queue data. */
3225
3226         for( i  = 0; i < qcount; i++) {
3227                 uint32 qjob, qsize, qpage_count, qstatus, qpriority, qtime;
3228                 len += tdb_unpack(data.dptr + len, data.dsize - len, "ddddddff",
3229                                 &qjob,
3230                                 &qsize,
3231                                 &qpage_count,
3232                                 &qstatus,
3233                                 &qpriority,
3234                                 &qtime,
3235                                 queue[i].fs_user,
3236                                 queue[i].fs_file);
3237                 queue[i].sysjob = qjob;
3238                 queue[i].size = qsize;
3239                 queue[i].page_count = qpage_count;
3240                 queue[i].status = qstatus;
3241                 queue[i].priority = qpriority;
3242                 queue[i].time = qtime;
3243         }
3244
3245         total_count = qcount;
3246
3247         /* Add new jobids to the queue. */
3248         for( i  = 0; i < extra_count; i++) {
3249                 uint32 jobid;
3250                 struct printjob *pjob;
3251
3252                 jobid = IVAL(cgdata.dptr, i*4);
3253                 DEBUG(5,("get_stored_queue_info: added job = %u\n", (unsigned int)jobid));
3254                 pjob = print_job_find(tmp_ctx, lp_const_servicename(snum), jobid);
3255                 if (!pjob) {
3256                         DEBUG(5,("get_stored_queue_info: failed to find added job = %u\n", (unsigned int)jobid));
3257                         remove_from_jobs_added(sharename, jobid);
3258                         continue;
3259                 }
3260
3261                 queue[total_count].sysjob = jobid;
3262                 queue[total_count].size = pjob->size;
3263                 queue[total_count].page_count = pjob->page_count;
3264                 queue[total_count].status = pjob->status;
3265                 queue[total_count].priority = 1;
3266                 queue[total_count].time = pjob->starttime;
3267                 fstrcpy(queue[total_count].fs_user, pjob->user);
3268                 fstrcpy(queue[total_count].fs_file, pjob->jobname);
3269                 total_count++;
3270                 talloc_free(pjob);
3271         }
3272
3273         /* Update the changed jobids. */
3274         for (i = 0; i < changed_count; i++) {
3275                 uint32_t jobid = IVAL(jcdata.dptr, i * 4);
3276                 uint32_t j;
3277                 bool found = false;
3278
3279                 for (j = 0; j < total_count; j++) {
3280                         if (queue[j].sysjob == jobid) {
3281                                 found = true;
3282                                 break;
3283                         }
3284                 }
3285
3286                 if (found) {
3287                         struct printjob *pjob;
3288
3289                         DEBUG(5,("get_stored_queue_info: changed job: %u\n",
3290                                  (unsigned int) jobid));
3291
3292                         pjob = print_job_find(tmp_ctx, sharename, jobid);
3293                         if (pjob == NULL) {
3294                                 DEBUG(5,("get_stored_queue_info: failed to find "
3295                                          "changed job = %u\n",
3296                                          (unsigned int) jobid));
3297                                 remove_from_jobs_changed(sharename, jobid);
3298                                 continue;
3299                         }
3300
3301                         queue[j].sysjob = jobid;
3302                         queue[j].size = pjob->size;
3303                         queue[j].page_count = pjob->page_count;
3304                         queue[j].status = pjob->status;
3305                         queue[j].priority = 1;
3306                         queue[j].time = pjob->starttime;
3307                         fstrcpy(queue[j].fs_user, pjob->user);
3308                         fstrcpy(queue[j].fs_file, pjob->jobname);
3309                         talloc_free(pjob);
3310
3311                         DEBUG(5,("get_stored_queue_info: updated queue[%u], jobid: %u, jobname: %s\n",
3312                                  (unsigned int) j, (unsigned int) jobid, pjob->jobname));
3313                 }
3314
3315                 remove_from_jobs_changed(sharename, jobid);
3316         }
3317
3318         /* Sort the queue by submission time otherwise they are displayed
3319            in hash order. */
3320
3321         TYPESAFE_QSORT(queue, total_count, printjob_comp);
3322
3323         DEBUG(5,("get_stored_queue_info: total_count = %u\n", (unsigned int)total_count));
3324
3325         if (max_reported_jobs && total_count > max_reported_jobs)
3326                 total_count = max_reported_jobs;
3327
3328         *ppqueue = queue;
3329         *pcount = total_count;
3330
3331         ret = True;
3332
3333   out:
3334
3335         SAFE_FREE(data.dptr);
3336         SAFE_FREE(cgdata.dptr);
3337         talloc_free(tmp_ctx);
3338         return ret;
3339 }
3340
3341 /****************************************************************************
3342  Get a printer queue listing.
3343  set queue = NULL and status = NULL if you just want to update the cache
3344 ****************************************************************************/
3345
3346 int print_queue_status(struct messaging_context *msg_ctx, int snum,
3347                        print_queue_struct **ppqueue,
3348                        print_status_struct *status)
3349 {
3350         fstring keystr;
3351         TDB_DATA data, key;
3352         const char *sharename;
3353         struct tdb_print_db *pdb;
3354         int count = 0;
3355
3356         /* make sure the database is up to date */
3357
3358         if (print_cache_expired(lp_const_servicename(snum), True))
3359                 print_queue_update(msg_ctx, snum, False);
3360
3361         /* return if we are done */
3362         if ( !ppqueue || !status )
3363                 return 0;
3364
3365         *ppqueue = NULL;
3366         sharename = lp_const_servicename(snum);
3367         pdb = get_print_db_byname(sharename);
3368
3369         if (!pdb)
3370                 return 0;
3371
3372         /*
3373          * Fetch the queue status.  We must do this first, as there may
3374          * be no jobs in the queue.
3375          */
3376
3377         ZERO_STRUCTP(status);
3378         slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", sharename);
3379         key = string_tdb_data(keystr);
3380
3381         data = tdb_fetch(pdb->tdb, key);
3382         if (data.dptr) {
3383                 if (data.dsize == sizeof(*status)) {
3384                         /* this memcpy is ok since the status struct was
3385                            not packed before storing it in the tdb */
3386                         memcpy(status, data.dptr, sizeof(*status));
3387                 }
3388                 SAFE_FREE(data.dptr);
3389         }
3390
3391         /*
3392          * Now, fetch the print queue information.  We first count the number
3393          * of entries, and then only retrieve the queue if necessary.
3394          */
3395
3396         if (!get_stored_queue_info(msg_ctx, pdb, snum, &count, ppqueue)) {
3397                 release_print_db(pdb);
3398                 return 0;
3399         }
3400
3401         release_print_db(pdb);
3402         return count;
3403 }
3404
3405 /****************************************************************************
3406  Pause a queue.
3407 ****************************************************************************/
3408
3409 WERROR print_queue_pause(const struct auth_serversupplied_info *server_info,
3410                          struct messaging_context *msg_ctx, int snum)
3411 {
3412         int ret;
3413         struct printif *current_printif = get_printer_fns( snum );
3414
3415         if (!print_access_check(server_info, msg_ctx, snum,
3416                                 PRINTER_ACCESS_ADMINISTER)) {
3417                 return WERR_ACCESS_DENIED;
3418         }
3419
3420
3421         become_root();
3422
3423         ret = (*(current_printif->queue_pause))(snum);
3424
3425         unbecome_root();
3426
3427         if (ret != 0) {
3428                 return WERR_INVALID_PARAM;
3429         }
3430
3431         /* force update the database */
3432         print_cache_flush(lp_const_servicename(snum));
3433
3434         /* Send a printer notify message */
3435
3436         notify_printer_status(server_event_context(), msg_ctx, snum,
3437                               PRINTER_STATUS_PAUSED);
3438
3439         return WERR_OK;
3440 }
3441
3442 /****************************************************************************
3443  Resume a queue.
3444 ****************************************************************************/
3445
3446 WERROR print_queue_resume(const struct auth_serversupplied_info *server_info,
3447                           struct messaging_context *msg_ctx, int snum)
3448 {
3449         int ret;
3450         struct printif *current_printif = get_printer_fns( snum );
3451
3452         if (!print_access_check(server_info, msg_ctx, snum,
3453                                 PRINTER_ACCESS_ADMINISTER)) {
3454                 return WERR_ACCESS_DENIED;
3455         }
3456
3457         become_root();
3458
3459         ret = (*(current_printif->queue_resume))(snum);
3460
3461         unbecome_root();
3462
3463         if (ret != 0) {
3464                 return WERR_INVALID_PARAM;
3465         }
3466
3467         /* make sure the database is up to date */
3468         if (print_cache_expired(lp_const_servicename(snum), True))
3469                 print_queue_update(msg_ctx, snum, True);
3470
3471         /* Send a printer notify message */
3472
3473         notify_printer_status(server_event_context(), msg_ctx, snum,
3474                               PRINTER_STATUS_OK);
3475
3476         return WERR_OK;
3477 }
3478
3479 /****************************************************************************
3480  Purge a queue - implemented by deleting all jobs that we can delete.
3481 ****************************************************************************/
3482
3483 WERROR print_queue_purge(const struct auth_serversupplied_info *server_info,
3484                          struct messaging_context *msg_ctx, int snum)
3485 {
3486         print_queue_struct *queue;
3487         print_status_struct status;
3488         int njobs, i;
3489         bool can_job_admin;
3490
3491         /* Force and update so the count is accurate (i.e. not a cached count) */
3492         print_queue_update(msg_ctx, snum, True);
3493
3494         can_job_admin = print_access_check(server_info,
3495                                            msg_ctx,
3496                                            snum,
3497                                            JOB_ACCESS_ADMINISTER);
3498         njobs = print_queue_status(msg_ctx, snum, &queue, &status);
3499
3500         if ( can_job_admin )
3501                 become_root();
3502
3503         for (i=0;i<njobs;i++) {
3504                 bool owner = is_owner(server_info, lp_const_servicename(snum),
3505                                       queue[i].sysjob);
3506
3507                 if (owner || can_job_admin) {
3508                         print_job_delete1(server_event_context(), msg_ctx,
3509                                           snum, queue[i].sysjob);
3510                 }
3511         }
3512
3513         if ( can_job_admin )
3514                 unbecome_root();
3515
3516         /* update the cache */
3517         print_queue_update(msg_ctx, snum, True);
3518
3519         SAFE_FREE(queue);
3520
3521         return WERR_OK;
3522 }