source/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 2 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, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "printing.h"
  24
  25 /* Current printer interface */
  26 static struct printif *current_printif = &generic_printif;
  27
  28 /*
  29    the printing backend revolves around a tdb database that stores the
  30    SMB view of the print queue
  31
  32    The key for this database is a jobid - a internally generated number that
  33    uniquely identifies a print job
  34
  35    reading the print queue involves two steps:
  36      - possibly running lpq and updating the internal database from that
  37      - reading entries from the database
  38
  39    jobids are assigned when a job starts spooling.
  40 */
  41
  42 /***************************************************************************
  43  Nightmare. LANMAN jobid's are 16 bit numbers..... We must map them to 32
  44  bit RPC jobids.... JRA.
  45 ***************************************************************************/
  46
  47 static TDB_CONTEXT *rap_tdb;
  48 static uint16 next_rap_jobid;
  49
  50 uint16 pjobid_to_rap(int snum, uint32 jobid)
  51 {
  52         uint16 rap_jobid;
  53         TDB_DATA data, key;
  54         char jinfo[8];
  55
  56         if (!rap_tdb) {
  57                 /* Create the in-memory tdb. */
  58                 rap_tdb = tdb_open_log(NULL, 0, TDB_INTERNAL, (O_RDWR|O_CREAT), 0644);
  59                 if (!rap_tdb)
  60                         return 0;
  61         }
  62
  63         SIVAL(&jinfo,0,(int32)snum);
  64         SIVAL(&jinfo,4,jobid);
  65
  66         key.dptr = (char *)&jinfo;
  67         key.dsize = sizeof(jinfo);
  68         data = tdb_fetch(rap_tdb, key);
  69         if (data.dptr && data.dsize == sizeof(uint16)) {
  70                 memcpy(&rap_jobid, data.dptr, sizeof(uint16));
  71                 SAFE_FREE(data.dptr);
  72                 return rap_jobid;
  73         }
  74         /* Not found - create and store mapping. */
  75         rap_jobid = ++next_rap_jobid;
  76         if (rap_jobid == 0)
  77                 rap_jobid = ++next_rap_jobid;
  78         data.dptr = (char *)&rap_jobid;
  79         data.dsize = sizeof(rap_jobid);
  80         tdb_store(rap_tdb, key, data, TDB_REPLACE);
  81         tdb_store(rap_tdb, data, key, TDB_REPLACE);
  82         return rap_jobid;
  83 }
  84
  85 BOOL rap_to_pjobid(uint16 rap_jobid, int *psnum, uint32 *pjobid)
  86 {
  87         TDB_DATA data, key;
  88         char jinfo[8];
  89
  90         if (!rap_tdb)
  91                 return False;
  92
  93         key.dptr = (char *)&rap_jobid;
  94         key.dsize = sizeof(rap_jobid);
  95         data = tdb_fetch(rap_tdb, key);
  96         if (data.dptr && data.dsize == sizeof(jinfo)) {
  97                 *psnum = IVAL(&jinfo,0);
  98                 *pjobid = IVAL(&jinfo,4);
  99                 SAFE_FREE(data.dptr);
 100                 return True;
 101         }
 102         return False;
 103 }
 104
 105 static void rap_jobid_delete(int snum, uint32 jobid)
 106 {
 107         TDB_DATA key, data;
 108         uint16 rap_jobid;
 109         char jinfo[8];
 110
 111         if (!rap_tdb)
 112                 return;
 113
 114         SIVAL(&jinfo,0,(int32)snum);
 115         SIVAL(&jinfo,4,jobid);
 116
 117         key.dptr = (char *)&jinfo;
 118         key.dsize = sizeof(jinfo);
 119         data = tdb_fetch(rap_tdb, key);
 120         if (!data.dptr || (data.dsize != sizeof(uint16)))
 121                 return;
 122
 123         memcpy(&rap_jobid, data.dptr, sizeof(uint16));
 124         SAFE_FREE(data.dptr);
 125         data.dptr = (char *)&rap_jobid;
 126         data.dsize = sizeof(rap_jobid);
 127         tdb_delete(rap_tdb, key);
 128         tdb_delete(rap_tdb, data);
 129 }
 130
 131 static pid_t local_pid;
 132
 133 static int get_queue_status(int, print_status_struct *);
 134
 135 /* There can be this many printing tdb's open, plus any locked ones. */
 136 #define MAX_PRINT_DBS_OPEN 1
 137
 138 struct tdb_print_db {
 139         struct tdb_print_db *next, *prev;
 140         TDB_CONTEXT *tdb;
 141         int ref_count;
 142         fstring printer_name;
 143 };
 144
 145 static struct tdb_print_db *print_db_head;
 146
 147 /****************************************************************************
 148   Function to find or create the printer specific job tdb given a printername.
 149   Limits the number of tdb's open to MAX_PRINT_DBS_OPEN.
 150 ****************************************************************************/
 151
 152 static struct tdb_print_db *get_print_db_byname(const char *printername)
 153 {
 154         struct tdb_print_db *p = NULL, *last_entry = NULL;
 155         int num_open = 0;
 156         pstring printdb_path;
 157
 158         for (p = print_db_head, last_entry = print_db_head; p; p = p->next) {
 159                 if (p->tdb && strequal(p->printer_name, printername)) {
 160                         DLIST_PROMOTE(print_db_head, p);
 161                         p->ref_count++;
 162                         return p;
 163                 }
 164                 num_open++;
 165                 last_entry = p;
 166         }
 167
 168         /* Not found. */
 169         if (num_open >= MAX_PRINT_DBS_OPEN) {
 170                 /* Try and recycle the last entry. */
 171                 DLIST_PROMOTE(print_db_head, last_entry);
 172
 173                 for (p = print_db_head; p; p = p->next) {
 174                         if (p->ref_count)
 175                                 continue;
 176                         if (p->tdb) {
 177                                 if (tdb_close(print_db_head->tdb)) {
 178                                         DEBUG(0,("get_print_db: Failed to close tdb for printer %s\n",
 179                                                                 print_db_head->printer_name ));
 180                                         return NULL;
 181                                 }
 182                         }
 183                         ZERO_STRUCTP(p);
 184                         break;
 185                 }
 186                 if (p) {
 187                         DLIST_PROMOTE(print_db_head, p);
 188                         p = print_db_head;
 189                 }
 190         }
 191
 192         if (!p) {
 193                 /* Create one. */
 194                 p = (struct tdb_print_db *)malloc(sizeof(struct tdb_print_db));
 195                 if (!p) {
 196                         DEBUG(0,("get_print_db: malloc fail !\n"));
 197                         return NULL;
 198                 }
 199                 ZERO_STRUCTP(p);
 200                 DLIST_ADD(print_db_head, p);
 201         }
 202
 203         pstrcpy(printdb_path, lock_path("printing/"));
 204         pstrcat(printdb_path, printername);
 205         pstrcat(printdb_path, ".tdb");
 206
 207         become_root();
 208         p->tdb = tdb_open_log(printdb_path, 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
 209         unbecome_root();
 210
 211         if (!p->tdb) {
 212                 DEBUG(0,("get_print_db: Failed to open printer backend database %s.\n",
 213                                         printdb_path ));
 214                 DLIST_REMOVE(print_db_head, p);
 215                 SAFE_FREE(p);
 216                 return NULL;
 217         }
 218         fstrcpy(p->printer_name, printername);
 219         p->ref_count++;
 220         return p;
 221 }
 222
 223 static void release_print_db( struct tdb_print_db *pdb)
 224 {
 225         pdb->ref_count--;
 226         SMB_ASSERT(pdb->ref_count >= 0);
 227 }
 228
 229 /****************************************************************************
 230  Initialise the printing backend. Called once at startup.
 231  Does not survive a fork
 232 ****************************************************************************/
 233
 234 BOOL print_backend_init(void)
 235 {
 236         char *sversion = "INFO/version";
 237         pstring printing_path;
 238         int services = lp_numservices();
 239         int snum;
 240
 241         if (local_pid == sys_getpid())
 242                 return True;
 243
 244         unlink(lock_path("printing.tdb"));
 245         pstrcpy(printing_path,lock_path("printing"));
 246         mkdir(printing_path,0755);
 247
 248         local_pid = sys_getpid();
 249
 250         /* handle a Samba upgrade */
 251
 252         for (snum = 0; snum < services; snum++) {
 253                 struct tdb_print_db *pdb;
 254                 if (!lp_print_ok(snum))
 255                         continue;
 256
 257                 pdb = get_print_db_byname(lp_const_servicename(snum));
 258                 if (!pdb)
 259                         continue;
 260                 if (tdb_lock_bystring(pdb->tdb, sversion) == -1) {
 261                         DEBUG(0,("print_backend_init: Failed to open printer %s database\n", lp_const_servicename(snum) ));
 262                         return False;
 263                 }
 264                 if (tdb_fetch_int32(pdb->tdb, sversion) != PRINT_DATABASE_VERSION) {
 265                         tdb_traverse(pdb->tdb, tdb_traverse_delete_fn, NULL);
 266                         tdb_store_int32(pdb->tdb, sversion, PRINT_DATABASE_VERSION);
 267                 }
 268                 tdb_unlock_bystring(pdb->tdb, sversion);
 269         }
 270
 271         /* select the appropriate printing interface... */
 272 #ifdef HAVE_CUPS
 273         if (strcmp(lp_printcapname(), "cups") == 0)
 274                 current_printif = &cups_printif;
 275 #endif /* HAVE_CUPS */
 276
 277         /* do NT print initialization... */
 278         return nt_printing_init();
 279 }
 280
 281 /****************************************************************************
 282  Shut down printing backend. Called once at shutdown to close the tdb.
 283 ****************************************************************************/
 284
 285 void printing_end(void)
 286 {
 287         struct tdb_print_db *p;
 288
 289         for (p = print_db_head; p; ) {
 290                 struct tdb_print_db *next_p = p->next;
 291                 if (p->tdb)
 292                         tdb_close(p->tdb);
 293                 DLIST_REMOVE(print_db_head, p);
 294                 SAFE_FREE(p);
 295                 p = next_p;
 296         }
 297 }
 298
 299 /****************************************************************************
 300  Useful function to generate a tdb key.
 301 ****************************************************************************/
 302
 303 static TDB_DATA print_key(uint32 jobid)
 304 {
 305         static uint32 j;
 306         TDB_DATA ret;
 307
 308         j = jobid;
 309         ret.dptr = (void *)&j;
 310         ret.dsize = sizeof(j);
 311         return ret;
 312 }
 313
 314 /***********************************************************************
 315  unpack a pjob from a tdb buffer
 316 ***********************************************************************/
 317
 318 int unpack_pjob( char* buf, int buflen, struct printjob *pjob )
 319 {
 320         int     len = 0;
 321         int     used;
 322
 323         if ( !buf || !pjob )
 324                 return -1;
 325
 326         len += tdb_unpack(buf+len, buflen-len, "dddddddddffff",
 327                                 &pjob->pid,
 328                                 &pjob->sysjob,
 329                                 &pjob->fd,
 330                                 &pjob->starttime,
 331                                 &pjob->status,
 332                                 &pjob->size,
 333                                 &pjob->page_count,
 334                                 &pjob->spooled,
 335                                 &pjob->smbjob,
 336                                 pjob->filename,
 337                                 pjob->jobname,
 338                                 pjob->user,
 339                                 pjob->queuename);
 340
 341         if ( len == -1 )
 342                 return -1;
 343
 344         if ( (used = unpack_devicemode(&pjob->nt_devmode, buf+len, buflen-len)) == -1 )
 345                 return -1;
 346
 347         len += used;
 348
 349         return len;
 350
 351 }
 352
 353 /****************************************************************************
 354  Useful function to find a print job in the database.
 355 ****************************************************************************/
 356
 357 static struct printjob *print_job_find(int snum, uint32 jobid)
 358 {
 359         static struct printjob  pjob;
 360         TDB_DATA                ret;
 361         struct tdb_print_db     *pdb = get_print_db_byname(lp_const_servicename(snum));
 362
 363
 364         if (!pdb)
 365                 return NULL;
 366
 367         ret = tdb_fetch(pdb->tdb, print_key(jobid));
 368         release_print_db(pdb);
 369
 370         if (!ret.dptr)
 371                 return NULL;
 372
 373         if ( pjob.nt_devmode )
 374                 free_nt_devicemode( &pjob.nt_devmode );
 375
 376         ZERO_STRUCT( pjob );
 377
 378         if ( unpack_pjob( ret.dptr, ret.dsize, &pjob ) == -1 )
 379                 return NULL;
 380
 381         SAFE_FREE(ret.dptr);
 382         return &pjob;
 383 }
 384
 385 /* Convert a unix jobid to a smb jobid */
 386
 387 static uint32 sysjob_to_jobid_value;
 388
 389 static int unixjob_traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA key,
 390                                TDB_DATA data, void *state)
 391 {
 392         struct printjob *pjob;
 393         int *sysjob = (int *)state;
 394
 395         if (!data.dptr || data.dsize == 0)
 396                 return 0;
 397
 398         pjob = (struct printjob *)data.dptr;
 399         if (key.dsize != sizeof(uint32))
 400                 return 0;
 401
 402         if (*sysjob == pjob->sysjob) {
 403                 uint32 *jobid = (uint32 *)key.dptr;
 404
 405                 sysjob_to_jobid_value = *jobid;
 406                 return 1;
 407         }
 408
 409         return 0;
 410 }
 411
 412 /****************************************************************************
 413  This is a *horribly expensive call as we have to iterate through all the
 414  current printer tdb's. Don't do this often ! JRA.
 415 ****************************************************************************/
 416
 417 uint32 sysjob_to_jobid(int unix_jobid)
 418 {
 419         int services = lp_numservices();
 420         int snum;
 421
 422         sysjob_to_jobid_value = (uint32)-1;
 423
 424         for (snum = 0; snum < services; snum++) {
 425                 struct tdb_print_db *pdb;
 426                 if (!lp_print_ok(snum))
 427                         continue;
 428                 pdb = get_print_db_byname(lp_const_servicename(snum));
 429                 if (pdb)
 430                         tdb_traverse(pdb->tdb, unixjob_traverse_fn, &unix_jobid);
 431                 release_print_db(pdb);
 432                 if (sysjob_to_jobid_value != (uint32)-1)
 433                         return sysjob_to_jobid_value;
 434         }
 435         return (uint32)-1;
 436 }
 437
 438 /****************************************************************************
 439  Send notifications based on what has changed after a pjob_store.
 440 ****************************************************************************/
 441
 442 static struct {
 443         uint32 lpq_status;
 444         uint32 spoolss_status;
 445 } lpq_to_spoolss_status_map[] = {
 446         { LPQ_QUEUED, JOB_STATUS_QUEUED },
 447         { LPQ_PAUSED, JOB_STATUS_PAUSED },
 448         { LPQ_SPOOLING, JOB_STATUS_SPOOLING },
 449         { LPQ_PRINTING, JOB_STATUS_PRINTING },
 450         { LPQ_DELETING, JOB_STATUS_DELETING },
 451         { LPQ_OFFLINE, JOB_STATUS_OFFLINE },
 452         { LPQ_PAPEROUT, JOB_STATUS_PAPEROUT },
 453         { LPQ_PRINTED, JOB_STATUS_PRINTED },
 454         { LPQ_DELETED, JOB_STATUS_DELETED },
 455         { LPQ_BLOCKED, JOB_STATUS_BLOCKED },
 456         { LPQ_USER_INTERVENTION, JOB_STATUS_USER_INTERVENTION },
 457         { -1, 0 }
 458 };
 459
 460 /* Convert a lpq status value stored in printing.tdb into the
 461    appropriate win32 API constant. */
 462
 463 static uint32 map_to_spoolss_status(uint32 lpq_status)
 464 {
 465         int i = 0;
 466
 467         while (lpq_to_spoolss_status_map[i].lpq_status != -1) {
 468                 if (lpq_to_spoolss_status_map[i].lpq_status == lpq_status)
 469                         return lpq_to_spoolss_status_map[i].spoolss_status;
 470                 i++;
 471         }
 472
 473         return 0;
 474 }
 475
 476 static void pjob_store_notify(int snum, uint32 jobid, struct printjob *old_data,
 477                               struct printjob *new_data)
 478 {
 479         BOOL new_job = False;
 480
 481         if (!old_data)
 482                 new_job = True;
 483
 484         /* Notify the job name first */
 485
 486         if (new_job || !strequal(old_data->jobname, new_data->jobname))
 487                 notify_job_name(snum, jobid, new_data->jobname);
 488
 489         /* Job attributes that can't be changed.  We only send
 490            notification for these on a new job. */
 491
 492         if (new_job) {
 493                 notify_job_submitted(snum, jobid, new_data->starttime);
 494                 notify_job_username(snum, jobid, new_data->user);
 495         }
 496
 497         /* Job attributes of a new job or attributes that can be
 498            modified. */
 499
 500         if (new_job || old_data->status != new_data->status)
 501                 notify_job_status(snum, jobid, map_to_spoolss_status(new_data->status));
 502
 503         if (new_job || old_data->size != new_data->size)
 504                 notify_job_total_bytes(snum, jobid, new_data->size);
 505
 506         if (new_job || old_data->page_count != new_data->page_count)
 507                 notify_job_total_pages(snum, jobid, new_data->page_count);
 508 }
 509
 510 /****************************************************************************
 511  Store a job structure back to the database.
 512 ****************************************************************************/
 513
 514 static BOOL pjob_store(int snum, uint32 jobid, struct printjob *pjob)
 515 {
 516         TDB_DATA                old_data, new_data;
 517         BOOL                    ret = False;
 518         struct tdb_print_db     *pdb = get_print_db_byname(lp_const_servicename(snum));
 519         char                    *buf = NULL;
 520         int                     len, newlen, buflen;
 521
 522
 523         if (!pdb)
 524                 return False;
 525
 526         /* Get old data */
 527
 528         old_data = tdb_fetch(pdb->tdb, print_key(jobid));
 529
 530         /* Doh!  Now we have to pack/unpack data since the NT_DEVICEMODE was added */
 531
 532         newlen = 0;
 533
 534         do {
 535                 len = 0;
 536                 buflen = newlen;
 537                 len += tdb_pack(buf+len, buflen-len, "dddddddddffff",
 538                                 pjob->pid,
 539                                 pjob->sysjob,
 540                                 pjob->fd,
 541                                 pjob->starttime,
 542                                 pjob->status,
 543                                 pjob->size,
 544                                 pjob->page_count,
 545                                 pjob->spooled,
 546                                 pjob->smbjob,
 547                                 pjob->filename,
 548                                 pjob->jobname,
 549                                 pjob->user,
 550                                 pjob->queuename);
 551
 552                 len += pack_devicemode(pjob->nt_devmode, buf+len, buflen-len);
 553
 554                 if (buflen != len)
 555                 {
 556                         char *tb;
 557
 558                         tb = (char *)Realloc(buf, len);
 559                         if (!tb) {
 560                                 DEBUG(0,("pjob_store: failed to enlarge buffer!\n"));
 561                                 goto done;
 562                         }
 563                         else
 564                                 buf = tb;
 565                         newlen = len;
 566                 }
 567         }
 568         while ( buflen != len );
 569
 570
 571         /* Store new data */
 572
 573         new_data.dptr = buf;
 574         new_data.dsize = len;
 575         ret = (tdb_store(pdb->tdb, print_key(jobid), new_data, TDB_REPLACE) == 0);
 576
 577         release_print_db(pdb);
 578
 579         /* Send notify updates for what has changed */
 580
 581         if ( ret && (old_data.dsize == 0 || old_data.dsize == sizeof(*pjob)) )
 582                 pjob_store_notify( snum, jobid, (struct printjob *)old_data.dptr, pjob );
 583
 584 done:
 585         SAFE_FREE( old_data.dptr );
 586         SAFE_FREE( buf );
 587
 588         return ret;
 589 }
 590
 591 /****************************************************************************
 592  Remove a job structure from the database.
 593 ****************************************************************************/
 594
 595 static void pjob_delete(int snum, uint32 jobid)
 596 {
 597         struct printjob *pjob = print_job_find(snum, jobid);
 598         uint32 job_status = 0;
 599         struct tdb_print_db *pdb = get_print_db_byname(lp_const_servicename(snum));
 600
 601         if (!pdb)
 602                 return;
 603
 604         if (!pjob) {
 605                 DEBUG(5, ("pjob_delete(): we were asked to delete nonexistent job %u\n",
 606                                         (unsigned int)jobid));
 607                 release_print_db(pdb);
 608                 return;
 609         }
 610
 611         /* Send a notification that a job has been deleted */
 612
 613         job_status = map_to_spoolss_status(pjob->status);
 614
 615         /* We must cycle through JOB_STATUS_DELETING and
 616            JOB_STATUS_DELETED for the port monitor to delete the job
 617            properly. */
 618
 619         job_status |= JOB_STATUS_DELETING;
 620         notify_job_status(snum, jobid, job_status);
 621
 622         job_status |= JOB_STATUS_DELETED;
 623         notify_job_status(snum, jobid, job_status);
 624
 625         /* Remove from printing.tdb */
 626
 627         tdb_delete(pdb->tdb, print_key(jobid));
 628         release_print_db(pdb);
 629         rap_jobid_delete(snum, jobid);
 630 }
 631
 632 /****************************************************************************
 633  Parse a file name from the system spooler to generate a jobid.
 634 ****************************************************************************/
 635
 636 static uint32 print_parse_jobid(char *fname)
 637 {
 638         int jobid;
 639
 640         if (strncmp(fname,PRINT_SPOOL_PREFIX,strlen(PRINT_SPOOL_PREFIX)) != 0)
 641                 return (uint32)-1;
 642         fname += strlen(PRINT_SPOOL_PREFIX);
 643
 644         jobid = atoi(fname);
 645         if (jobid <= 0)
 646                 return (uint32)-1;
 647
 648         return (uint32)jobid;
 649 }
 650
 651 /****************************************************************************
 652  List a unix job in the print database.
 653 ****************************************************************************/
 654
 655 static void print_unix_job(int snum, print_queue_struct *q)
 656 {
 657         uint32 jobid = q->job + UNIX_JOB_START;
 658         struct printjob pj, *old_pj;
 659
 660         /* Preserve the timestamp on an existing unix print job */
 661
 662         old_pj = print_job_find(snum, jobid);
 663
 664         ZERO_STRUCT(pj);
 665
 666         pj.pid = (pid_t)-1;
 667         pj.sysjob = q->job;
 668         pj.fd = -1;
 669         pj.starttime = old_pj ? old_pj->starttime : q->time;
 670         pj.status = q->status;
 671         pj.size = q->size;
 672         pj.spooled = True;
 673         pj.smbjob = False;
 674         fstrcpy(pj.filename, "");
 675         fstrcpy(pj.jobname, q->fs_file);
 676         fstrcpy(pj.user, q->fs_user);
 677         fstrcpy(pj.queuename, lp_const_servicename(snum));
 678
 679         pjob_store(snum, jobid, &pj);
 680 }
 681
 682
 683 struct traverse_struct {
 684         print_queue_struct *queue;
 685         int qcount, snum, maxcount, total_jobs;
 686 };
 687
 688 /****************************************************************************
 689  Utility fn to delete any jobs that are no longer active.
 690 ****************************************************************************/
 691
 692 static int traverse_fn_delete(TDB_CONTEXT *t, TDB_DATA key, TDB_DATA data, void *state)
 693 {
 694         struct traverse_struct *ts = (struct traverse_struct *)state;
 695         struct printjob pjob;
 696         uint32 jobid;
 697         int i;
 698
 699         if (  key.dsize != sizeof(jobid) )
 700                 return 0;
 701
 702         memcpy(&jobid, key.dptr, sizeof(jobid));
 703         if ( unpack_pjob( data.dptr, data.dsize, &pjob ) == -1 )
 704                 return 0;
 705         free_nt_devicemode( &pjob.nt_devmode );
 706
 707
 708         if (ts->snum != lp_servicenumber(pjob.queuename)) {
 709                 /* this isn't for the queue we are looking at - this cannot happen with the split tdb's. JRA */
 710                 return 0;
 711         }
 712
 713         if (!pjob.smbjob) {
 714                 /* remove a unix job if it isn't in the system queue any more */
 715
 716                 for (i=0;i<ts->qcount;i++) {
 717                         uint32 u_jobid = (ts->queue[i].job + UNIX_JOB_START);
 718                         if (jobid == u_jobid)
 719                                 break;
 720                 }
 721                 if (i == ts->qcount)
 722                         pjob_delete(ts->snum, jobid);
 723                 else
 724                         ts->total_jobs++;
 725                 return 0;
 726         }
 727
 728         /* maybe it hasn't been spooled yet */
 729         if (!pjob.spooled) {
 730                 /* if a job is not spooled and the process doesn't
 731                    exist then kill it. This cleans up after smbd
 732                    deaths */
 733                 if (!process_exists(pjob.pid))
 734                         pjob_delete(ts->snum, jobid);
 735                 else
 736                         ts->total_jobs++;
 737                 return 0;
 738         }
 739
 740         for (i=0;i<ts->qcount;i++) {
 741                 uint32 curr_jobid = print_parse_jobid(ts->queue[i].fs_file);
 742                 if (jobid == curr_jobid)
 743                         break;
 744         }
 745
 746         /* The job isn't in the system queue - we have to assume it has
 747            completed, so delete the database entry. */
 748
 749         if (i == ts->qcount) {
 750                 time_t cur_t = time(NULL);
 751
 752                 /* A race can occur between the time a job is spooled and
 753                    when it appears in the lpq output.  This happens when
 754                    the job is added to printing.tdb when another smbd
 755                    running print_queue_update() has completed a lpq and
 756                    is currently traversing the printing tdb and deleting jobs.
 757                    A workaround is to not delete the job if it has been
 758                    submitted less than lp_lpqcachetime() seconds ago. */
 759
 760                 if ((cur_t - pjob.starttime) > lp_lpqcachetime())
 761                         pjob_delete(ts->snum, jobid);
 762                 else
 763                         ts->total_jobs++;
 764         }
 765         else
 766                 ts->total_jobs++;
 767
 768         return 0;
 769 }
 770
 771 /****************************************************************************
 772  Check if the print queue has been updated recently enough.
 773 ****************************************************************************/
 774
 775 static void print_cache_flush(int snum)
 776 {
 777         fstring key;
 778         const char *printername = lp_const_servicename(snum);
 779         struct tdb_print_db *pdb = get_print_db_byname(printername);
 780
 781         if (!pdb)
 782                 return;
 783         slprintf(key, sizeof(key)-1, "CACHE/%s", printername);
 784         tdb_store_int32(pdb->tdb, key, -1);
 785         release_print_db(pdb);
 786 }
 787
 788 /****************************************************************************
 789  Check if someone already thinks they are doing the update.
 790 ****************************************************************************/
 791
 792 static pid_t get_updating_pid(fstring printer_name)
 793 {
 794         fstring keystr;
 795         TDB_DATA data, key;
 796         pid_t updating_pid;
 797         struct tdb_print_db *pdb = get_print_db_byname(printer_name);
 798
 799         if (!pdb)
 800                 return (pid_t)-1;
 801         slprintf(keystr, sizeof(keystr)-1, "UPDATING/%s", printer_name);
 802         key.dptr = keystr;
 803         key.dsize = strlen(keystr);
 804
 805         data = tdb_fetch(pdb->tdb, key);
 806         release_print_db(pdb);
 807         if (!data.dptr || data.dsize != sizeof(pid_t))
 808                 return (pid_t)-1;
 809
 810         memcpy(&updating_pid, data.dptr, sizeof(pid_t));
 811         SAFE_FREE(data.dptr);
 812
 813         if (process_exists(updating_pid))
 814                 return updating_pid;
 815
 816         return (pid_t)-1;
 817 }
 818
 819 /****************************************************************************
 820  Set the fact that we're doing the update, or have finished doing the update
 821  in the tdb.
 822 ****************************************************************************/
 823
 824 static void set_updating_pid(const fstring printer_name, BOOL delete)
 825 {
 826         fstring keystr;
 827         TDB_DATA key;
 828         TDB_DATA data;
 829         pid_t updating_pid = sys_getpid();
 830         struct tdb_print_db *pdb = get_print_db_byname(printer_name);
 831
 832         if (!pdb)
 833                 return;
 834
 835         slprintf(keystr, sizeof(keystr)-1, "UPDATING/%s", printer_name);
 836         key.dptr = keystr;
 837         key.dsize = strlen(keystr);
 838
 839         if (delete) {
 840                 tdb_delete(pdb->tdb, key);
 841                 release_print_db(pdb);
 842                 return;
 843         }
 844
 845         data.dptr = (void *)&updating_pid;
 846         data.dsize = sizeof(pid_t);
 847
 848         tdb_store(pdb->tdb, key, data, TDB_REPLACE);
 849         release_print_db(pdb);
 850 }
 851
 852 /****************************************************************************
 853  Update the internal database from the system print queue for a queue.
 854 ****************************************************************************/
 855
 856 static void print_queue_update(int snum)
 857 {
 858         int i, qcount;
 859         print_queue_struct *queue = NULL;
 860         print_status_struct status;
 861         print_status_struct old_status;
 862         struct printjob *pjob;
 863         struct traverse_struct tstruct;
 864         fstring keystr, printer_name, cachestr;
 865         TDB_DATA data, key;
 866         struct tdb_print_db *pdb;
 867
 868         fstrcpy(printer_name, lp_const_servicename(snum));
 869         pdb = get_print_db_byname(printer_name);
 870         if (!pdb)
 871                 return;
 872
 873         /*
 874          * Check to see if someone else is doing this update.
 875          * This is essentially a mutex on the update.
 876          */
 877
 878         if (get_updating_pid(printer_name) != -1) {
 879                 release_print_db(pdb);
 880                 return;
 881         }
 882
 883         /* Lock the queue for the database update */
 884
 885         slprintf(keystr, sizeof(keystr) - 1, "LOCK/%s", printer_name);
 886         if (tdb_lock_bystring(pdb->tdb, keystr) == -1) {
 887                 DEBUG(0,("print_queue_update: Failed to lock printer %s database\n", printer_name));
 888                 release_print_db(pdb);
 889                 return;
 890         }
 891
 892         /*
 893          * Ensure that no one else got in here.
 894          * If the updating pid is still -1 then we are
 895          * the winner.
 896          */
 897
 898         if (get_updating_pid(printer_name) != -1) {
 899                 /*
 900                  * Someone else is doing the update, exit.
 901                  */
 902                 tdb_unlock_bystring(pdb->tdb, keystr);
 903                 release_print_db(pdb);
 904                 return;
 905         }
 906
 907         /*
 908          * We're going to do the update ourselves.
 909          */
 910
 911         /* Tell others we're doing the update. */
 912         set_updating_pid(printer_name, False);
 913
 914         /*
 915          * Allow others to enter and notice we're doing
 916          * the update.
 917          */
 918
 919         tdb_unlock_bystring(pdb->tdb, keystr);
 920
 921         /*
 922          * Update the cache time FIRST ! Stops others even
 923          * attempting to get the lock and doing this
 924          * if the lpq takes a long time.
 925          */
 926
 927         slprintf(cachestr, sizeof(cachestr)-1, "CACHE/%s", printer_name);
 928         tdb_store_int32(pdb->tdb, cachestr, (int)time(NULL));
 929
 930         /* get the current queue using the appropriate interface */
 931         ZERO_STRUCT(status);
 932
 933         qcount = (*(current_printif->queue_get))(snum, &queue, &status);
 934
 935         DEBUG(3, ("%d job%s in queue for %s\n", qcount, (qcount != 1) ?
 936                 "s" : "", printer_name));
 937
 938         /*
 939           any job in the internal database that is marked as spooled
 940           and doesn't exist in the system queue is considered finished
 941           and removed from the database
 942
 943           any job in the system database but not in the internal database
 944           is added as a unix job
 945
 946           fill in any system job numbers as we go
 947         */
 948         for (i=0; i<qcount; i++) {
 949                 uint32 jobid = print_parse_jobid(queue[i].fs_file);
 950
 951                 if (jobid == (uint32)-1) {
 952                         /* assume its a unix print job */
 953                         print_unix_job(snum, &queue[i]);
 954                         continue;
 955                 }
 956
 957                 /* we have an active SMB print job - update its status */
 958                 pjob = print_job_find(snum, jobid);
 959                 if (!pjob) {
 960                         /* err, somethings wrong. Probably smbd was restarted
 961                            with jobs in the queue. All we can do is treat them
 962                            like unix jobs. Pity. */
 963                         print_unix_job(snum, &queue[i]);
 964                         continue;
 965                 }
 966
 967                 pjob->sysjob = queue[i].job;
 968                 pjob->status = queue[i].status;
 969
 970                 pjob_store(snum, jobid, pjob);
 971         }
 972
 973         /* now delete any queued entries that don't appear in the
 974            system queue */
 975         tstruct.queue = queue;
 976         tstruct.qcount = qcount;
 977         tstruct.snum = snum;
 978         tstruct.total_jobs = 0;
 979
 980         tdb_traverse(pdb->tdb, traverse_fn_delete, (void *)&tstruct);
 981
 982         SAFE_FREE(tstruct.queue);
 983
 984         tdb_store_int32(pdb->tdb, "INFO/total_jobs", tstruct.total_jobs);
 985
 986         if( qcount != get_queue_status(snum, &old_status))
 987                 DEBUG(10,("print_queue_update: queue status change %d jobs -> %d jobs for printer %s\n",
 988                                         old_status.qcount, qcount, printer_name ));
 989
 990         /* store the new queue status structure */
 991         slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", printer_name);
 992         key.dptr = keystr;
 993         key.dsize = strlen(keystr);
 994
 995         status.qcount = qcount;
 996         data.dptr = (void *)&status;
 997         data.dsize = sizeof(status);
 998         tdb_store(pdb->tdb, key, data, TDB_REPLACE);
 999
1000         /*
1001          * Update the cache time again. We want to do this call
1002          * as little as possible...
1003          */
1004
1005         slprintf(keystr, sizeof(keystr)-1, "CACHE/%s", printer_name);
1006         tdb_store_int32(pdb->tdb, keystr, (int32)time(NULL));
1007
1008         /* Delete our pid from the db. */
1009         set_updating_pid(printer_name, True);
1010         release_print_db(pdb);
1011 }
1012
1013 /****************************************************************************
1014  Check if a jobid is valid. It is valid if it exists in the database.
1015 ****************************************************************************/
1016
1017 BOOL print_job_exists(int snum, uint32 jobid)
1018 {
1019         struct tdb_print_db *pdb = get_print_db_byname(lp_const_servicename(snum));
1020         BOOL ret;
1021
1022         if (!pdb)
1023                 return False;
1024         ret = tdb_exists(pdb->tdb, print_key(jobid));
1025         release_print_db(pdb);
1026         return ret;
1027 }
1028
1029 /****************************************************************************
1030  Give the fd used for a jobid.
1031 ****************************************************************************/
1032
1033 int print_job_fd(int snum, uint32 jobid)
1034 {
1035         struct printjob *pjob = print_job_find(snum, jobid);
1036         if (!pjob)
1037                 return -1;
1038         /* don't allow another process to get this info - it is meaningless */
1039         if (pjob->pid != local_pid)
1040                 return -1;
1041         return pjob->fd;
1042 }
1043
1044 /****************************************************************************
1045  Give the filename used for a jobid.
1046  Only valid for the process doing the spooling and when the job
1047  has not been spooled.
1048 ****************************************************************************/
1049
1050 char *print_job_fname(int snum, uint32 jobid)
1051 {
1052         struct printjob *pjob = print_job_find(snum, jobid);
1053         if (!pjob || pjob->spooled || pjob->pid != local_pid)
1054                 return NULL;
1055         return pjob->filename;
1056 }
1057
1058
1059 /****************************************************************************
1060  Give the filename used for a jobid.
1061  Only valid for the process doing the spooling and when the job
1062  has not been spooled.
1063 ****************************************************************************/
1064
1065 NT_DEVICEMODE *print_job_devmode(int snum, uint32 jobid)
1066 {
1067         struct printjob *pjob = print_job_find(snum, jobid);
1068
1069         if ( !pjob )
1070                 return NULL;
1071
1072         return pjob->nt_devmode;
1073 }
1074
1075 /****************************************************************************
1076  Set the place in the queue for a job.
1077 ****************************************************************************/
1078
1079 BOOL print_job_set_place(int snum, uint32 jobid, int place)
1080 {
1081         DEBUG(2,("print_job_set_place not implemented yet\n"));
1082         return False;
1083 }
1084
1085 /****************************************************************************
1086  Set the name of a job. Only possible for owner.
1087 ****************************************************************************/
1088
1089 BOOL print_job_set_name(int snum, uint32 jobid, char *name)
1090 {
1091         struct printjob *pjob = print_job_find(snum, jobid);
1092         if (!pjob || pjob->pid != local_pid)
1093                 return False;
1094
1095         fstrcpy(pjob->jobname, name);
1096         return pjob_store(snum, jobid, pjob);
1097 }
1098
1099 /****************************************************************************
1100  Delete a print job - don't update queue.
1101 ****************************************************************************/
1102
1103 static BOOL print_job_delete1(int snum, uint32 jobid)
1104 {
1105         struct printjob *pjob = print_job_find(snum, jobid);
1106         int result = 0;
1107
1108         if (!pjob)
1109                 return False;
1110
1111         /*
1112          * If already deleting just return.
1113          */
1114
1115         if (pjob->status == LPQ_DELETING)
1116                 return True;
1117
1118         /* Hrm - we need to be able to cope with deleting a job before it
1119            has reached the spooler. */
1120
1121         if (pjob->sysjob == -1) {
1122                 DEBUG(5, ("attempt to delete job %u not seen by lpr\n", (unsigned int)jobid));
1123         }
1124
1125         /* Set the tdb entry to be deleting. */
1126
1127         pjob->status = LPQ_DELETING;
1128         pjob_store(snum, jobid, pjob);
1129
1130         if (pjob->spooled && pjob->sysjob != -1)
1131                 result = (*(current_printif->job_delete))(snum, pjob);
1132
1133         /* Delete the tdb entry if the delete suceeded or the job hasn't
1134            been spooled. */
1135
1136         if (result == 0)
1137                 pjob_delete(snum, jobid);
1138
1139         return (result == 0);
1140 }
1141
1142 /****************************************************************************
1143  Return true if the current user owns the print job.
1144 ****************************************************************************/
1145
1146 static BOOL is_owner(struct current_user *user, int snum, uint32 jobid)
1147 {
1148         struct printjob *pjob = print_job_find(snum, jobid);
1149         user_struct *vuser;
1150
1151         if (!pjob || !user)
1152                 return False;
1153
1154         if ((vuser = get_valid_user_struct(user->vuid)) != NULL) {
1155                 return strequal(pjob->user, vuser->user.smb_name);
1156         } else {
1157                 return strequal(pjob->user, uidtoname(user->uid));
1158         }
1159 }
1160
1161 /****************************************************************************
1162  Delete a print job.
1163 ****************************************************************************/
1164
1165 BOOL print_job_delete(struct current_user *user, int snum, uint32 jobid, WERROR *errcode)
1166 {
1167         BOOL    owner, deleted;
1168         char    *fname;
1169
1170         *errcode = WERR_OK;
1171
1172         owner = is_owner(user, snum, jobid);
1173
1174         /* Check access against security descriptor or whether the user
1175            owns their job. */
1176
1177         if (!owner &&
1178             !print_access_check(user, snum, JOB_ACCESS_ADMINISTER)) {
1179                 DEBUG(3, ("delete denied by security descriptor\n"));
1180                 *errcode = WERR_ACCESS_DENIED;
1181                 return False;
1182         }
1183
1184         /*
1185          * get the spooled filename of the print job
1186          * if this works, then the file has not been spooled
1187          * to the underlying print system.  Just delete the
1188          * spool file & return.
1189          */
1190
1191         if ( (fname = print_job_fname( snum, jobid )) != NULL )
1192         {
1193                 /* remove the spool file */
1194                 DEBUG(10,("print_job_delete: Removing spool file [%s]\n", fname ));
1195                 if ( unlink( fname ) == -1 ) {
1196                         *errcode = map_werror_from_unix(errno);
1197                         return False;
1198                 }
1199
1200                 return True;
1201         }
1202
1203         if (!print_job_delete1(snum, jobid)) {
1204                 *errcode = WERR_ACCESS_DENIED;
1205                 return False;
1206         }
1207
1208         /* force update the database and say the delete failed if the
1209            job still exists */
1210
1211         print_queue_update(snum);
1212
1213         deleted = !print_job_exists(snum, jobid);
1214         if ( !deleted )
1215                 *errcode = WERR_ACCESS_DENIED;
1216
1217         return deleted;
1218 }
1219
1220 /****************************************************************************
1221  Pause a job.
1222 ****************************************************************************/
1223
1224 BOOL print_job_pause(struct current_user *user, int snum, uint32 jobid, WERROR *errcode)
1225 {
1226         struct printjob *pjob = print_job_find(snum, jobid);
1227         int ret = -1;
1228
1229         if (!pjob || !user)
1230                 return False;
1231
1232         if (!pjob->spooled || pjob->sysjob == -1)
1233                 return False;
1234
1235         if (!is_owner(user, snum, jobid) &&
1236             !print_access_check(user, snum, JOB_ACCESS_ADMINISTER)) {
1237                 DEBUG(3, ("pause denied by security descriptor\n"));
1238                 *errcode = WERR_ACCESS_DENIED;
1239                 return False;
1240         }
1241
1242         /* need to pause the spooled entry */
1243         ret = (*(current_printif->job_pause))(snum, pjob);
1244
1245         if (ret != 0) {
1246                 *errcode = WERR_INVALID_PARAM;
1247                 return False;
1248         }
1249
1250         /* force update the database */
1251         print_cache_flush(snum);
1252
1253         /* Send a printer notify message */
1254
1255         notify_job_status(snum, jobid, JOB_STATUS_PAUSED);
1256
1257         /* how do we tell if this succeeded? */
1258
1259         return True;
1260 }
1261
1262 /****************************************************************************
1263  Resume a job.
1264 ****************************************************************************/
1265
1266 BOOL print_job_resume(struct current_user *user, int snum, uint32 jobid, WERROR *errcode)
1267 {
1268         struct printjob *pjob = print_job_find(snum, jobid);
1269         int ret;
1270
1271         if (!pjob || !user)
1272                 return False;
1273
1274         if (!pjob->spooled || pjob->sysjob == -1)
1275                 return False;
1276
1277         if (!is_owner(user, snum, jobid) &&
1278             !print_access_check(user, snum, JOB_ACCESS_ADMINISTER)) {
1279                 DEBUG(3, ("resume denied by security descriptor\n"));
1280                 *errcode = WERR_ACCESS_DENIED;
1281                 return False;
1282         }
1283
1284         ret = (*(current_printif->job_resume))(snum, pjob);
1285
1286         if (ret != 0) {
1287                 *errcode = WERR_INVALID_PARAM;
1288                 return False;
1289         }
1290
1291         /* force update the database */
1292         print_cache_flush(snum);
1293
1294         /* Send a printer notify message */
1295
1296         notify_job_status(snum, jobid, JOB_STATUS_QUEUED);
1297
1298         return True;
1299 }
1300
1301 /****************************************************************************
1302  Write to a print file.
1303 ****************************************************************************/
1304
1305 int print_job_write(int snum, uint32 jobid, const char *buf, int size)
1306 {
1307         int return_code;
1308         struct printjob *pjob = print_job_find(snum, jobid);
1309
1310         if (!pjob)
1311                 return -1;
1312         /* don't allow another process to get this info - it is meaningless */
1313         if (pjob->pid != local_pid)
1314                 return -1;
1315
1316         return_code = write(pjob->fd, buf, size);
1317         if (return_code>0) {
1318                 pjob->size += size;
1319                 pjob_store(snum, jobid, pjob);
1320         }
1321         return return_code;
1322 }
1323
1324 /****************************************************************************
1325  Check if the print queue has been updated recently enough.
1326 ****************************************************************************/
1327
1328 static BOOL print_cache_expired(int snum)
1329 {
1330         fstring key;
1331         time_t last_qscan_time, time_now = time(NULL);
1332         const char *printername = lp_const_servicename(snum);
1333         struct tdb_print_db *pdb = get_print_db_byname(printername);
1334
1335         if (!pdb)
1336                 return False;
1337
1338         slprintf(key, sizeof(key), "CACHE/%s", printername);
1339         last_qscan_time = (time_t)tdb_fetch_int32(pdb->tdb, key);
1340
1341         /*
1342          * Invalidate the queue for 3 reasons.
1343          * (1). last queue scan time == -1.
1344          * (2). Current time - last queue scan time > allowed cache time.
1345          * (3). last queue scan time > current time + MAX_CACHE_VALID_TIME (1 hour by default).
1346          * This last test picks up machines for which the clock has been moved
1347          * forward, an lpq scan done and then the clock moved back. Otherwise
1348          * that last lpq scan would stay around for a loooong loooong time... :-). JRA.
1349          */
1350
1351         if (last_qscan_time == ((time_t)-1) || (time_now - last_qscan_time) >= lp_lpqcachetime() ||
1352                         last_qscan_time > (time_now + MAX_CACHE_VALID_TIME)) {
1353                 DEBUG(3, ("print cache expired for queue %s \
1354 (last_qscan_time = %d, time now = %d, qcachetime = %d)\n", printername,
1355                         (int)last_qscan_time, (int)time_now, (int)lp_lpqcachetime() ));
1356                 release_print_db(pdb);
1357                 return True;
1358         }
1359         release_print_db(pdb);
1360         return False;
1361 }
1362
1363 /****************************************************************************
1364  Get the queue status - do not update if db is out of date.
1365 ****************************************************************************/
1366
1367 static int get_queue_status(int snum, print_status_struct *status)
1368 {
1369         fstring keystr;
1370         TDB_DATA data, key;
1371         const char *printername = lp_const_servicename(snum);
1372         struct tdb_print_db *pdb = get_print_db_byname(printername);
1373         if (!pdb)
1374                 return 0;
1375
1376         ZERO_STRUCTP(status);
1377         slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", printername);
1378         key.dptr = keystr;
1379         key.dsize = strlen(keystr);
1380         data = tdb_fetch(pdb->tdb, key);
1381         release_print_db(pdb);
1382         if (data.dptr) {
1383                 if (data.dsize == sizeof(print_status_struct)) {
1384                         memcpy(status, data.dptr, sizeof(print_status_struct));
1385                 }
1386                 SAFE_FREE(data.dptr);
1387         }
1388         return status->qcount;
1389 }
1390
1391 /****************************************************************************
1392  Determine the number of jobs in a queue.
1393 ****************************************************************************/
1394
1395 int print_queue_length(int snum, print_status_struct *pstatus)
1396 {
1397         print_status_struct status;
1398         int len;
1399
1400         /* make sure the database is up to date */
1401         if (print_cache_expired(snum))
1402                 print_queue_update(snum);
1403
1404         /* also fetch the queue status */
1405         memset(&status, 0, sizeof(status));
1406         len = get_queue_status(snum, &status);
1407         if (pstatus)
1408                 *pstatus = status;
1409         return len;
1410 }
1411
1412 /***************************************************************************
1413  Start spooling a job - return the jobid.
1414 ***************************************************************************/
1415
1416 uint32 print_job_start(struct current_user *user, int snum, char *jobname, NT_DEVICEMODE *nt_devmode )
1417 {
1418         uint32 jobid;
1419         char *path;
1420         struct printjob pjob;
1421         int next_jobid;
1422         user_struct *vuser;
1423         int njobs = 0;
1424         const char *printername = lp_const_servicename(snum);
1425         struct tdb_print_db *pdb = get_print_db_byname(printername);
1426         BOOL pdb_locked = False;
1427
1428         errno = 0;
1429
1430         if (!pdb)
1431                 return (uint32)-1;
1432
1433         if (!print_access_check(user, snum, PRINTER_ACCESS_USE)) {
1434                 DEBUG(3, ("print_job_start: job start denied by security descriptor\n"));
1435                 release_print_db(pdb);
1436                 return (uint32)-1;
1437         }
1438
1439         if (!print_time_access_check(snum)) {
1440                 DEBUG(3, ("print_job_start: job start denied by time check\n"));
1441                 release_print_db(pdb);
1442                 return (uint32)-1;
1443         }
1444
1445         path = lp_pathname(snum);
1446
1447         /* see if we have sufficient disk space */
1448         if (lp_minprintspace(snum)) {
1449                 SMB_BIG_UINT dspace, dsize;
1450                 if (sys_fsusage(path, &dspace, &dsize) == 0 &&
1451                     dspace < 2*(SMB_BIG_UINT)lp_minprintspace(snum)) {
1452                         DEBUG(3, ("print_job_start: disk space check failed.\n"));
1453                         release_print_db(pdb);
1454                         errno = ENOSPC;
1455                         return (uint32)-1;
1456                 }
1457         }
1458
1459         /* for autoloaded printers, check that the printcap entry still exists */
1460         if (lp_autoloaded(snum) && !pcap_printername_ok(lp_const_servicename(snum), NULL)) {
1461                 DEBUG(3, ("print_job_start: printer name %s check failed.\n", lp_const_servicename(snum) ));
1462                 release_print_db(pdb);
1463                 errno = ENOENT;
1464                 return (uint32)-1;
1465         }
1466
1467         /* Insure the maximum queue size is not violated */
1468         if (lp_maxprintjobs(snum) && (njobs = print_queue_length(snum,NULL)) > lp_maxprintjobs(snum)) {
1469                 DEBUG(3, ("print_job_start: number of jobs (%d) larger than max printjobs per queue (%d).\n",
1470                         njobs, lp_maxprintjobs(snum) ));
1471                 release_print_db(pdb);
1472                 errno = ENOSPC;
1473                 return (uint32)-1;
1474         }
1475
1476         /* Lock the database */
1477         if (tdb_lock_bystring(pdb->tdb, "INFO/nextjob") == -1) {
1478                 DEBUG(0,("print_job_start: failed to lock printing database %s\n", printername ));
1479                 release_print_db(pdb);
1480                 return (uint32)-1;
1481         }
1482
1483         pdb_locked = True;
1484
1485         next_jobid = tdb_fetch_int32(pdb->tdb, "INFO/nextjob");
1486         if (next_jobid == -1)
1487                 next_jobid = 1;
1488
1489         for (jobid = NEXT_JOBID(next_jobid); jobid != next_jobid; jobid = NEXT_JOBID(jobid)) {
1490                 if (!print_job_exists(snum, jobid))
1491                         break;
1492         }
1493
1494         if (jobid == next_jobid) {
1495                 DEBUG(3, ("print_job_start: jobid (%d)==next_jobid(%d).\n",
1496                                 jobid, next_jobid ));
1497                 jobid = -1;
1498                 goto fail;
1499         }
1500
1501         /* Store a dummy placeholder. This must be quick as we have the lock. */
1502         {
1503                 TDB_DATA dum;
1504                 dum.dptr = NULL;
1505                 dum.dsize = 0;
1506                 if (tdb_store(pdb->tdb, print_key(jobid), dum, TDB_INSERT) == -1) {
1507                         DEBUG(3, ("print_job_start: jobid (%d) failed to store placeholder.\n",
1508                                 jobid ));
1509                         jobid = -1;
1510                         goto fail;
1511                 }
1512         }
1513
1514         if (tdb_store_int32(pdb->tdb, "INFO/nextjob", jobid)==-1) {
1515                 DEBUG(3, ("print_job_start: failed to store INFO/nextjob.\n"));
1516                 jobid = -1;
1517                 goto fail;
1518         }
1519
1520         /* We've finished with the INFO/nextjob lock. */
1521         tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
1522         pdb_locked = False;
1523
1524         /* create the database entry */
1525
1526         ZERO_STRUCT(pjob);
1527
1528         pjob.pid = local_pid;
1529         pjob.sysjob = -1;
1530         pjob.fd = -1;
1531         pjob.starttime = time(NULL);
1532         pjob.status = LPQ_SPOOLING;
1533         pjob.size = 0;
1534         pjob.spooled = False;
1535         pjob.smbjob = True;
1536         pjob.nt_devmode = nt_devmode;
1537
1538         fstrcpy(pjob.jobname, jobname);
1539
1540         if ((vuser = get_valid_user_struct(user->vuid)) != NULL) {
1541                 fstrcpy(pjob.user, vuser->user.smb_name);
1542         } else {
1543                 fstrcpy(pjob.user, uidtoname(user->uid));
1544         }
1545
1546         fstrcpy(pjob.queuename, lp_const_servicename(snum));
1547
1548         /* we have a job entry - now create the spool file */
1549         slprintf(pjob.filename, sizeof(pjob.filename)-1, "%s/%s%.8u.XXXXXX",
1550                  path, PRINT_SPOOL_PREFIX, (unsigned int)jobid);
1551         pjob.fd = smb_mkstemp(pjob.filename);
1552
1553         if (pjob.fd == -1) {
1554                 if (errno == EACCES) {
1555                         /* Common setup error, force a report. */
1556                         DEBUG(0, ("print_job_start: insufficient permissions \
1557 to open spool file %s.\n", pjob.filename));
1558                 } else {
1559                         /* Normal case, report at level 3 and above. */
1560                         DEBUG(3, ("print_job_start: can't open spool file %s,\n", pjob.filename));
1561                         DEBUGADD(3, ("errno = %d (%s).\n", errno, strerror(errno)));
1562                 }
1563                 goto fail;
1564         }
1565
1566         pjob_store(snum, jobid, &pjob);
1567
1568         release_print_db(pdb);
1569
1570         /*
1571          * If the printer is marked as postscript output a leading
1572          * file identifier to ensure the file is treated as a raw
1573          * postscript file.
1574          * This has a similar effect as CtrlD=0 in WIN.INI file.
1575          * tim@fsg.com 09/06/94
1576          */
1577         if (lp_postscript(snum)) {
1578                 print_job_write(snum, jobid, "%!\n",3);
1579         }
1580
1581         return jobid;
1582
1583  fail:
1584         if (jobid != -1)
1585                 pjob_delete(snum, jobid);
1586
1587         if (pdb_locked)
1588                 tdb_unlock_bystring(pdb->tdb, "INFO/nextjob");
1589         release_print_db(pdb);
1590
1591         DEBUG(3, ("print_job_start: returning fail. Error = %s\n", strerror(errno) ));
1592         return -1;
1593 }
1594
1595 /****************************************************************************
1596  Update the number of pages spooled to jobid
1597 ****************************************************************************/
1598
1599 void print_job_endpage(int snum, uint32 jobid)
1600 {
1601         struct printjob *pjob = print_job_find(snum, jobid);
1602         if (!pjob)
1603                 return;
1604         /* don't allow another process to get this info - it is meaningless */
1605         if (pjob->pid != local_pid)
1606                 return;
1607
1608         pjob->page_count++;
1609         pjob_store(snum, jobid, pjob);
1610 }
1611
1612 /****************************************************************************
1613  Print a file - called on closing the file. This spools the job.
1614  If normal close is false then we're tearing down the jobs - treat as an
1615  error.
1616 ****************************************************************************/
1617
1618 BOOL print_job_end(int snum, uint32 jobid, BOOL normal_close)
1619 {
1620         struct printjob *pjob = print_job_find(snum, jobid);
1621         int ret;
1622         SMB_STRUCT_STAT sbuf;
1623
1624         if (!pjob)
1625                 return False;
1626
1627         if (pjob->spooled || pjob->pid != local_pid)
1628                 return False;
1629
1630         if (normal_close && (sys_fstat(pjob->fd, &sbuf) == 0)) {
1631                 pjob->size = sbuf.st_size;
1632                 close(pjob->fd);
1633                 pjob->fd = -1;
1634         } else {
1635
1636                 /*
1637                  * Not a normal close or we couldn't stat the job file,
1638                  * so something has gone wrong. Cleanup.
1639                  */
1640                 close(pjob->fd);
1641                 pjob->fd = -1;
1642                 DEBUG(3,("print_job_end: failed to stat file for jobid %d\n", jobid ));
1643                 goto fail;
1644         }
1645
1646         /* Technically, this is not quite right. If the printer has a separator
1647          * page turned on, the NT spooler prints the separator page even if the
1648          * print job is 0 bytes. 010215 JRR */
1649         if (pjob->size == 0 || pjob->status == LPQ_DELETING) {
1650                 /* don't bother spooling empty files or something being deleted. */
1651                 DEBUG(5,("print_job_end: canceling spool of %s (%s)\n",
1652                         pjob->filename, pjob->size ? "deleted" : "zero length" ));
1653                 unlink(pjob->filename);
1654                 pjob_delete(snum, jobid);
1655                 return True;
1656         }
1657
1658         ret = (*(current_printif->job_submit))(snum, pjob);
1659
1660         if (ret)
1661                 goto fail;
1662
1663         /* The print job has been sucessfully handed over to the back-end */
1664
1665         pjob->spooled = True;
1666         pjob->status = LPQ_QUEUED;
1667         pjob_store(snum, jobid, pjob);
1668
1669         /* make sure the database is up to date */
1670         if (print_cache_expired(snum))
1671                 print_queue_update(snum);
1672
1673         return True;
1674
1675 fail:
1676
1677         /* The print job was not succesfully started. Cleanup */
1678         /* Still need to add proper error return propagation! 010122:JRR */
1679         unlink(pjob->filename);
1680         pjob_delete(snum, jobid);
1681         return False;
1682 }
1683
1684 /****************************************************************************
1685  Utility fn to enumerate the print queue.
1686 ****************************************************************************/
1687
1688 static int traverse_fn_queue(TDB_CONTEXT *t, TDB_DATA key, TDB_DATA data, void *state)
1689 {
1690         struct traverse_struct *ts = (struct traverse_struct *)state;
1691         struct printjob pjob;
1692         int i;
1693         uint32 jobid;
1694
1695         /* sanity checks */
1696
1697         if ( key.dsize != sizeof(jobid) )
1698                 return 0;
1699
1700         memcpy(&jobid, key.dptr, sizeof(jobid));
1701
1702         if ( unpack_pjob( data.dptr, data.dsize, &pjob ) == -1 )
1703                 return 0;
1704         free_nt_devicemode( &pjob.nt_devmode );
1705
1706         /* maybe it isn't for this queue */
1707         if (ts->snum != lp_servicenumber(pjob.queuename))
1708                 return 0;
1709
1710         if (ts->qcount >= ts->maxcount)
1711                 return 0;
1712
1713         i = ts->qcount;
1714
1715         ts->queue[i].job = jobid;
1716         ts->queue[i].size = pjob.size;
1717         ts->queue[i].page_count = pjob.page_count;
1718         ts->queue[i].status = pjob.status;
1719         ts->queue[i].priority = 1;
1720         ts->queue[i].time = pjob.starttime;
1721         fstrcpy(ts->queue[i].fs_user, pjob.user);
1722         fstrcpy(ts->queue[i].fs_file, pjob.jobname);
1723
1724         ts->qcount++;
1725
1726         return 0;
1727 }
1728
1729 struct traverse_count_struct {
1730         int snum, count;
1731 };
1732
1733 /****************************************************************************
1734  Utility fn to count the number of entries in the print queue.
1735 ****************************************************************************/
1736
1737 static int traverse_count_fn_queue(TDB_CONTEXT *t, TDB_DATA key, TDB_DATA data, void *state)
1738 {
1739         struct traverse_count_struct *ts = (struct traverse_count_struct *)state;
1740         struct printjob pjob;
1741         uint32 jobid;
1742
1743         /* sanity checks */
1744
1745         if (  key.dsize != sizeof(jobid) )
1746                 return 0;
1747
1748         memcpy(&jobid, key.dptr, sizeof(jobid));
1749
1750         if ( unpack_pjob( data.dptr, data.dsize, &pjob ) == -1 )
1751                 return 0;
1752
1753         free_nt_devicemode( &pjob.nt_devmode );
1754
1755         /* maybe it isn't for this queue - this cannot happen with the tdb/printer code. JRA */
1756         if (ts->snum != lp_servicenumber(pjob.queuename))
1757                 return 0;
1758
1759         ts->count++;
1760
1761         return 0;
1762 }
1763
1764 /****************************************************************************
1765  Sort print jobs by submittal time.
1766 ****************************************************************************/
1767
1768 static int printjob_comp(print_queue_struct *j1, print_queue_struct *j2)
1769 {
1770         /* Silly cases */
1771
1772         if (!j1 && !j2)
1773                 return 0;
1774         if (!j1)
1775                 return -1;
1776         if (!j2)
1777                 return 1;
1778
1779         /* Sort on job start time */
1780
1781         if (j1->time == j2->time)
1782                 return 0;
1783         return (j1->time > j2->time) ? 1 : -1;
1784 }
1785
1786 /****************************************************************************
1787  Get a printer queue listing.
1788 ****************************************************************************/
1789
1790 int print_queue_status(int snum,
1791                        print_queue_struct **queue,
1792                        print_status_struct *status)
1793 {
1794         struct traverse_struct tstruct;
1795         struct traverse_count_struct tsc;
1796         fstring keystr;
1797         TDB_DATA data, key;
1798         const char *printername = lp_const_servicename(snum);
1799         struct tdb_print_db *pdb = get_print_db_byname(printername);
1800
1801         *queue = NULL;
1802
1803         if (!pdb)
1804                 return 0;
1805
1806         /* make sure the database is up to date */
1807         if (print_cache_expired(snum))
1808                 print_queue_update(snum);
1809
1810         /*
1811          * Fetch the queue status.  We must do this first, as there may
1812          * be no jobs in the queue.
1813          */
1814         ZERO_STRUCTP(status);
1815         slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", printername);
1816         key.dptr = keystr;
1817         key.dsize = strlen(keystr);
1818         data = tdb_fetch(pdb->tdb, key);
1819         if (data.dptr) {
1820                 if (data.dsize == sizeof(*status)) {
1821                         memcpy(status, data.dptr, sizeof(*status));
1822                 }
1823                 SAFE_FREE(data.dptr);
1824         }
1825
1826         /*
1827          * Now, fetch the print queue information.  We first count the number
1828          * of entries, and then only retrieve the queue if necessary.
1829          */
1830         tsc.count = 0;
1831         tsc.snum = snum;
1832
1833         tdb_traverse(pdb->tdb, traverse_count_fn_queue, (void *)&tsc);
1834
1835         if (tsc.count == 0) {
1836                 release_print_db(pdb);
1837                 return 0;
1838         }
1839
1840         /* Allocate the queue size. */
1841         if ((tstruct.queue = (print_queue_struct *)
1842              malloc(sizeof(print_queue_struct)*tsc.count)) == NULL) {
1843                 release_print_db(pdb);
1844                 return 0;
1845         }
1846
1847         /*
1848          * Fill in the queue.
1849          * We need maxcount as the queue size may have changed between
1850          * the two calls to tdb_traverse.
1851          */
1852         tstruct.qcount = 0;
1853         tstruct.maxcount = tsc.count;
1854         tstruct.snum = snum;
1855
1856         tdb_traverse(pdb->tdb, traverse_fn_queue, (void *)&tstruct);
1857         release_print_db(pdb);
1858
1859         /* Sort the queue by submission time otherwise they are displayed
1860            in hash order. */
1861
1862         qsort(tstruct.queue, tstruct.qcount, sizeof(print_queue_struct),
1863               QSORT_CAST(printjob_comp));
1864
1865         *queue = tstruct.queue;
1866         return tstruct.qcount;
1867 }
1868
1869 /****************************************************************************
1870  Turn a queue name into a snum.
1871 ****************************************************************************/
1872
1873 int print_queue_snum(const char *qname)
1874 {
1875         int snum = lp_servicenumber(qname);
1876         if (snum == -1 || !lp_print_ok(snum))
1877                 return -1;
1878         return snum;
1879 }
1880
1881 /****************************************************************************
1882  Pause a queue.
1883 ****************************************************************************/
1884
1885 BOOL print_queue_pause(struct current_user *user, int snum, WERROR *errcode)
1886 {
1887         int ret;
1888
1889         if (!print_access_check(user, snum, PRINTER_ACCESS_ADMINISTER)) {
1890                 *errcode = WERR_ACCESS_DENIED;
1891                 return False;
1892         }
1893
1894         ret = (*(current_printif->queue_pause))(snum);
1895
1896         if (ret != 0) {
1897                 *errcode = WERR_INVALID_PARAM;
1898                 return False;
1899         }
1900
1901         /* force update the database */
1902         print_cache_flush(snum);
1903
1904         /* Send a printer notify message */
1905
1906         notify_printer_status(snum, PRINTER_STATUS_PAUSED);
1907
1908         return True;
1909 }
1910
1911 /****************************************************************************
1912  Resume a queue.
1913 ****************************************************************************/
1914
1915 BOOL print_queue_resume(struct current_user *user, int snum, WERROR *errcode)
1916 {
1917         int ret;
1918
1919         if (!print_access_check(user, snum, PRINTER_ACCESS_ADMINISTER)) {
1920                 *errcode = WERR_ACCESS_DENIED;
1921                 return False;
1922         }
1923
1924         ret = (*(current_printif->queue_resume))(snum);
1925
1926         if (ret != 0) {
1927                 *errcode = WERR_INVALID_PARAM;
1928                 return False;
1929         }
1930
1931         /* make sure the database is up to date */
1932         if (print_cache_expired(snum))
1933                 print_queue_update(snum);
1934
1935         /* Send a printer notify message */
1936
1937         notify_printer_status(snum, PRINTER_STATUS_OK);
1938
1939         return True;
1940 }
1941
1942 /****************************************************************************
1943  Purge a queue - implemented by deleting all jobs that we can delete.
1944 ****************************************************************************/
1945
1946 BOOL print_queue_purge(struct current_user *user, int snum, WERROR *errcode)
1947 {
1948         print_queue_struct *queue;
1949         print_status_struct status;
1950         int njobs, i;
1951         BOOL can_job_admin;
1952
1953         /* Force and update so the count is accurate (i.e. not a cached count) */
1954         print_queue_update(snum);
1955
1956         can_job_admin = print_access_check(user, snum, JOB_ACCESS_ADMINISTER);
1957         njobs = print_queue_status(snum, &queue, &status);
1958
1959         for (i=0;i<njobs;i++) {
1960                 BOOL owner = is_owner(user, snum, queue[i].job);
1961
1962                 if (owner || can_job_admin) {
1963                         print_job_delete1(snum, queue[i].job);
1964                 }
1965         }
1966
1967         SAFE_FREE(queue);
1968
1969         return True;
1970 }