root/source3/printing/printing.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. pjobid_to_rap
  2. rap_to_pjobid
  3. rap_jobid_delete
  4. print_backend_init
  5. printing_end
  6. get_printer_fns_from_type
  7. get_printer_fns
  8. print_key
  9. unpack_pjob
  10. print_job_find
  11. unixjob_traverse_fn
  12. sysjob_to_jobid
  13. map_to_spoolss_status
  14. pjob_store_notify
  15. pjob_store
  16. pjob_delete
  17. print_parse_jobid
  18. print_unix_job
  19. traverse_fn_delete
  20. print_cache_flush
  21. get_updating_pid
  22. set_updating_pid
  23. printjob_comp
  24. store_queue_struct
  25. get_jobs_changed_data
  26. check_job_changed
  27. print_cache_expired
  28. print_queue_update_internal
  29. print_queue_update_with_lock
  30. print_queue_receive
  31. printing_pause_fd_handler
  32. start_background_queue
  33. print_queue_update
  34. print_notify_register_pid
  35. print_notify_deregister_pid
  36. print_job_exists
  37. print_job_fd
  38. print_job_fname
  39. print_job_devmode
  40. print_job_set_place
  41. print_job_set_name
  42. remove_from_jobs_changed
  43. print_job_delete1
  44. is_owner
  45. print_job_delete
  46. print_job_pause
  47. print_job_resume
  48. print_job_write
  49. get_queue_status
  50. print_queue_length
  51. allocate_print_jobid
  52. add_to_jobs_changed
  53. print_job_start
  54. print_job_endpage
  55. print_job_end
  56. get_stored_queue_info
  57. print_queue_status
  58. print_queue_pause
  59. print_queue_resume
  60. print_queue_purge

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

/* [<][>][^][v][top][bottom][index][help] */