Update scheduler to use new environment variable API - this reduces code

[thirdparty/cups.git] / scheduler / job.c

/*
 * "$Id$"
 *
 *   Job management routines for the Common UNIX Printing System (CUPS).
 *
 *   Copyright 1997-2005 by Easy Software Products, all rights reserved.
 *
 *   These coded instructions, statements, and computer programs are the
 *   property of Easy Software Products and are protected by Federal
 *   copyright law.  Distribution and use rights are outlined in the file
 *   "LICENSE.txt" which should have been included with this file.  If this
 *   file is missing or damaged please contact Easy Software Products
 *   at:
 *
 *       Attn: CUPS Licensing Information
 *       Easy Software Products
 *       44141 Airport View Drive, Suite 204
 *       Hollywood, Maryland 20636 USA
 *
 *       Voice: (301) 373-9600
 *       EMail: cups-info@cups.org
 *         WWW: http://www.cups.org
 *
 * Contents:
 *
 *   AddJob()             - Add a new job to the job queue...
 *   CancelJob()          - Cancel the specified print job.
 *   CancelJobs()         - Cancel all jobs for the given destination/user...
 *   CheckJobs()          - Check the pending jobs and start any if the
 *                          destination is available.
 *   CleanJobs()          - Clean out old jobs.
 *   FreeAllJobs()        - Free all jobs from memory.
 *   FindJob()            - Find the specified job.
 *   GetPrinterJobCount() - Get the number of pending, processing,
 *                          or held jobs in a printer or class.
 *   GetUserJobCount()    - Get the number of pending, processing,
 *                          or held jobs for a user.
 *   HoldJob()            - Hold the specified job.
 *   LoadAllJobs()        - Load all jobs from disk.
 *   MoveJob()            - Move the specified job to a different
 *                          destination.
 *   ReleaseJob()         - Release the specified job.
 *   RestartJob()         - Restart the specified job.
 *   SaveJob()            - Save a job to disk.
 *   SetJobHoldUntil()    - Set the hold time for a job...
 *   SetJobPriority()     - Set the priority of a job, moving it up/down
 *                          in the list as needed.
 *   StartJob()           - Start a print job.
 *   StopAllJobs()        - Stop all print jobs.
 *   StopJob()            - Stop a print job.
 *   UpdateJob()          - Read a status update from a job's filters.
 *   ipp_length()         - Compute the size of the buffer needed to hold 
 *                          the textual IPP attributes.
 *   set_hold_until()     - Set the hold time and update job-hold-until attribute.
 */

/*
 * Include necessary headers...
 */

#include "cupsd.h"
#include <grp.h>
#include <cups/dir.h>


/*
 * Local globals...
 */

static mime_filter_t    gziptoany_filter =
                        {
                          NULL,         /* Source type */
                          NULL,         /* Destination type */
                          0,            /* Cost */
                          "gziptoany"   /* Filter program to run */
                        };


/*
 * Local functions...
 */

static int              ipp_length(ipp_t *ipp);
static void             set_time(job_t *job, const char *name);
static void             set_hold_until(job_t *job, time_t holdtime);


/*
 * 'AddJob()' - Add a new job to the job queue...
 */

job_t *                                 /* O - New job record */
AddJob(int        priority,             /* I - Job priority */
       const char *dest)                /* I - Job destination */
{
  job_t *job,                           /* New job record */
        *current,                       /* Current job in queue */
        *prev;                          /* Previous job in queue */


  job = calloc(sizeof(job_t), 1);

  job->id             = NextJobId ++;
  job->priority       = priority;
  job->back_pipes[0]  = -1;
  job->back_pipes[1]  = -1;
  job->print_pipes[0] = -1;
  job->print_pipes[1] = -1;

  SetString(&job->dest, dest);

  NumJobs ++;

  for (current = Jobs, prev = NULL;
       current != NULL;
       prev = current, current = current->next)
    if (job->priority > current->priority)
      break;

  job->next = current;
  if (prev != NULL)
    prev->next = job;
  else
    Jobs = job;

  return (job);
}


/*
 * 'CancelJob()' - Cancel the specified print job.
 */

void
CancelJob(int id,                       /* I - Job to cancel */
          int purge)                    /* I - Purge jobs? */
{
  int   i;                              /* Looping var */
  job_t *current,                       /* Current job */
        *prev;                          /* Previous job in list */
  char  filename[1024];                 /* Job filename */


  LogMessage(L_DEBUG, "CancelJob: id = %d", id);

  for (current = Jobs, prev = NULL; current != NULL; prev = current, current = current->next)
    if (current->id == id)
    {
     /*
      * Stop any processes that are working on the current...
      */

      DEBUG_puts("CancelJob: found job in list.");

      if (current->state->values[0].integer == IPP_JOB_PROCESSING)
        StopJob(current->id, 0);

      current->state->values[0].integer = IPP_JOB_CANCELLED;

      set_time(current, "time-at-completed");

      cupsdExpireSubscriptions(NULL, current);

     /*
      * Remove the print file for good if we aren't preserving jobs or
      * files...
      */

      current->current_file = 0;

      if (!JobHistory || !JobFiles || purge ||
          (current->dtype & CUPS_PRINTER_REMOTE))
        for (i = 1; i <= current->num_files; i ++)
        {
          snprintf(filename, sizeof(filename), "%s/d%05d-%03d", RequestRoot,
                   current->id, i);
          unlink(filename);
        }

      if (JobHistory && !purge && !(current->dtype & CUPS_PRINTER_REMOTE))
      {
       /*
        * Save job state info...
        */

        SaveJob(current->id);
      }
      else
      {
       /*
        * Remove the job info file...
        */

        snprintf(filename, sizeof(filename), "%s/c%05d", RequestRoot,
                 current->id);
        unlink(filename);

       /*
        * Update pointers if we aren't preserving jobs...
        */

        if (prev == NULL)
          Jobs = current->next;
        else
          prev->next = current->next;

       /*
        * Free all memory used...
        */

        if (current->attrs != NULL)
          ippDelete(current->attrs);

        if (current->num_files > 0)
        {
          free(current->compressions);
          free(current->filetypes);
        }

        ClearString(&current->username);
        ClearString(&current->dest);

        free(current);

        NumJobs --;
      }

      return;
    }
}


/*
 * 'CancelJobs()' - Cancel all jobs for the given destination/user...
 */

void
CancelJobs(const char *dest,            /* I - Destination to cancel */
           const char *username,        /* I - Username or NULL */
           int        purge)            /* I - Purge jobs? */
{
  job_t *current,                       /* Current job */
        *next;                          /* Next job */


  for (current = Jobs; current != NULL;)
    if ((dest == NULL || !strcmp(current->dest, dest)) &&
        (username == NULL || !strcmp(current->username, username)))
    {
     /*
      * Cancel all jobs matching this destination/user...
      */

      next = current->next;

      cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, current->printer, current,
                    purge ? "Job purged." : "Job canceled.");

      CancelJob(current->id, purge);

      current = next;
    }
    else
      current = current->next;

  CheckJobs();
}


/*
 * 'CheckJobs()' - Check the pending jobs and start any if the destination
 *                 is available.
 */

void
CheckJobs(void)
{
  job_t         *current,               /* Current job in queue */
                *next;                  /* Next job in queue */
  printer_t     *printer,               /* Printer destination */
                *pclass;                /* Printer class destination */


  DEBUG_puts("CheckJobs()");

  for (current = Jobs; current != NULL; current = next)
  {
   /*
    * Save next pointer in case the job is cancelled en-route.
    */

    next = current->next;

   /*
    * Start held jobs if they are ready...
    */

    if (current->state->values[0].integer == IPP_JOB_HELD &&
        current->hold_until &&
        current->hold_until < time(NULL))
      current->state->values[0].integer = IPP_JOB_PENDING;

   /*
    * Start pending jobs if the destination is available...
    */

    if (current->state->values[0].integer == IPP_JOB_PENDING && !NeedReload)
    {
      if ((pclass = FindClass(current->dest)) != NULL)
      {
       /*
        * If the class is remote, just pass it to the remote server...
        */

        if (pclass->type & CUPS_PRINTER_REMOTE)
          printer = pclass;
        else if (pclass->state != IPP_PRINTER_STOPPED)
          printer = FindAvailablePrinter(current->dest);
        else
          printer = NULL;
      }
      else
        printer = FindPrinter(current->dest);

      if (printer != NULL && (printer->type & CUPS_PRINTER_IMPLICIT))
      {
       /*
        * Handle implicit classes...
        */

        pclass = printer;

        if (pclass->state != IPP_PRINTER_STOPPED)
          printer = FindAvailablePrinter(current->dest);
        else
          printer = NULL;
      }

      if (printer == NULL && pclass == NULL)
      {
       /*
        * Whoa, the printer and/or class for this destination went away;
        * cancel the job...
        */

        LogMessage(L_WARN, "Printer/class %s has gone away; cancelling job %d!",
                   current->dest, current->id);

        cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, current->printer, current,
                      "Job cancelled because the destination printer/class has gone away.");

        CancelJob(current->id, 1);
      }
      else if (printer != NULL)
      {
       /*
        * See if the printer is available or remote and not printing a job;
        * if so, start the job...
        */

        if (printer->state == IPP_PRINTER_IDLE ||       /* Printer is idle */
            ((printer->type & CUPS_PRINTER_REMOTE) &&   /* Printer is remote */
             !printer->job))                            /* and not printing a job */
          StartJob(current->id, printer);
      }
    }
  }
}


/*
 * 'CleanJobs()' - Clean out old jobs.
 */

void
CleanJobs(void)
{
  job_t *job,                           /* Current job */
        *next;                          /* Next job */


  if (MaxJobs == 0)
    return;

  for (job = Jobs; job && NumJobs >= MaxJobs; job = next)
  {
    next = job->next;

    if (job->state->values[0].integer >= IPP_JOB_CANCELLED)
      CancelJob(job->id, 1);
  }
}


/*
 * 'FinishJob()' - Finish a job.
 */

void
FinishJob(job_t *job)                   /* I - Job */
{
  int           job_history;            /* Did CancelJob() keep the job? */
  printer_t     *printer;               /* Current printer */


  LogMessage(L_DEBUG, "FinishJob: job %d, file %d is complete.",
             job->id, job->current_file - 1);

  LogMessage(L_DEBUG2, "FinishJob: job->status is %d", job->status);

  if (job->status_buffer && job->current_file >= job->num_files)
  {
   /*
    * Close the pipe and clear the input bit.
    */

    LogMessage(L_DEBUG2, "FinishJob: Removing fd %d from InputSet...",
               job->status_buffer->fd);

    FD_CLR(job->status_buffer->fd, InputSet);

    LogMessage(L_DEBUG2, "FinishJob: Closing status input pipe %d...",
               job->status_buffer->fd);

    cupsdStatBufDelete(job->status_buffer);

    job->status_buffer = NULL;
  }

  if (job->status < 0)
  {
   /*
    * Backend had errors; stop it...
    */

    printer = job->printer;

    StopJob(job->id, 0);
    job->state->values[0].integer = IPP_JOB_PENDING;
    SaveJob(job->id);

   /*
    * If the job was queued to a class, try requeuing it...  For
    * faxes and retry-job queues, hold the current job for 5 minutes.
    */

    if (job->dtype & (CUPS_PRINTER_CLASS | CUPS_PRINTER_IMPLICIT))
      CheckJobs();
    else if ((printer->type & CUPS_PRINTER_FAX) ||
             !strcmp(printer->error_policy, "retry-job"))
    {
     /*
      * See how many times we've tried to send the job; if more than
      * the limit, cancel the job.
      */

      job->tries ++;

      if (job->tries >= FaxRetryLimit)
      {
       /*
        * Too many tries...
        */

        LogMessage(L_ERROR, "Canceling job %d since it could not be sent after %d tries.",
                   job->id, FaxRetryLimit);

        cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, job->printer, job,
                      "Job cancelled since it could not be sent after %d tries.",
                      FaxRetryLimit);

        CancelJob(job->id, 0);
      }
      else
      {
       /*
        * Try again in N seconds...
        */

        set_hold_until(job, time(NULL) + FaxRetryInterval);
      }

      CheckJobs();
    }
    else if (!strcmp(printer->error_policy, "abort-job"))
      CheckJobs();
  }
  else if (job->status > 0)
  {
   /*
    * Filter had errors; cancel it...
    */

    if (job->current_file < job->num_files)
      StartJob(job->id, job->printer);
    else
    {
      cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, job->printer, job,
                    "Job aborted due to filter errors; please consult the "
                    "error_log file for details.");

      job_history = JobHistory && !(job->dtype & CUPS_PRINTER_REMOTE);

      CancelJob(job->id, 0);

      if (job_history)
      {
        job->state->values[0].integer = IPP_JOB_ABORTED;
        SaveJob(job->id);
      }

      CheckJobs();
    }
  }
  else
  {
   /*
    * Job printed successfully; cancel it...
    */

    if (job->current_file < job->num_files)
    {
      FilterLevel -= job->cost;
      StartJob(job->id, job->printer);
    }
    else
    {
      cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, job->printer, job,
                    "Job completed successfully.");

      job_history = JobHistory && !(job->dtype & CUPS_PRINTER_REMOTE);

      CancelJob(job->id, 0);

      if (job_history)
      {
        job->state->values[0].integer = IPP_JOB_COMPLETED;
        SaveJob(job->id);
      }

      CheckJobs();
    }
  }
}


/*
 * 'FreeAllJobs()' - Free all jobs from memory.
 */

void
FreeAllJobs(void)
{
  job_t *job,                           /* Current job */
        *next;                          /* Next job */


  HoldSignals();

  StopAllJobs();

  for (job = Jobs; job; job = next)
  {
    next = job->next;

    ippDelete(job->attrs);

    if (job->num_files > 0)
    {
      free(job->compressions);
      free(job->filetypes);
    }

    free(job);
  }

  Jobs = NULL;

  ReleaseSignals();
}


/*
 * 'FindJob()' - Find the specified job.
 */

job_t *                                 /* O - Job data */
FindJob(int id)                         /* I - Job ID */
{
  job_t *current;                       /* Current job */


  for (current = Jobs; current != NULL; current = current->next)
    if (current->id == id)
      break;

  return (current);
}


/*
 * 'GetPrinterJobCount()' - Get the number of pending, processing,
 *                          or held jobs in a printer or class.
 */

int                                     /* O - Job count */
GetPrinterJobCount(const char *dest)    /* I - Printer or class name */
{
  int   count;                          /* Job count */
  job_t *job;                           /* Current job */


  for (job = Jobs, count = 0; job != NULL; job = job->next)
    if (job->state->values[0].integer <= IPP_JOB_PROCESSING &&
        strcasecmp(job->dest, dest) == 0)
      count ++;

  return (count);
}


/*
 * 'GetUserJobCount()' - Get the number of pending, processing,
 *                       or held jobs for a user.
 */

int                                     /* O - Job count */
GetUserJobCount(const char *username)   /* I - Username */
{
  int   count;                          /* Job count */
  job_t *job;                           /* Current job */


  for (job = Jobs, count = 0; job != NULL; job = job->next)
    if (job->state->values[0].integer <= IPP_JOB_PROCESSING &&
        strcmp(job->username, username) == 0)
      count ++;

  return (count);
}


/*
 * 'HoldJob()' - Hold the specified job.
 */

void
HoldJob(int id)                         /* I - Job ID */
{
  job_t *job;                           /* Job data */


  LogMessage(L_DEBUG, "HoldJob: id = %d", id);

  if ((job = FindJob(id)) == NULL)
    return;

  if (job->state->values[0].integer == IPP_JOB_PROCESSING)
    StopJob(id, 0);

  DEBUG_puts("HoldJob: setting state to held...");

  job->state->values[0].integer = IPP_JOB_HELD;

  SaveJob(id);

  CheckJobs();
}


/*
 * 'LoadAllJobs()' - Load all jobs from disk.
 */

void
LoadAllJobs(void)
{
  cups_dir_t    *dir;                   /* Directory */
  cups_dentry_t *dent;                  /* Directory entry */
  char          filename[1024];         /* Full filename of job file */
  int           fd;                     /* File descriptor */
  job_t         *job,                   /* New job */
                *current,               /* Current job */
                *prev;                  /* Previous job */
  int           jobid,                  /* Current job ID */
                fileid;                 /* Current file ID */
  ipp_attribute_t *attr;                /* Job attribute */
  char          method[HTTP_MAX_URI],   /* Method portion of URI */
                username[HTTP_MAX_URI], /* Username portion of URI */
                host[HTTP_MAX_URI],     /* Host portion of URI */
                resource[HTTP_MAX_URI]; /* Resource portion of URI */
  int           port;                   /* Port portion of URI */
  printer_t     *p;                     /* Printer or class */
  const char    *dest;                  /* Destination */
  mime_type_t   **filetypes;            /* New filetypes array */
  int           *compressions;          /* New compressions array */


 /*
  * First open the requests directory...
  */

  LogMessage(L_DEBUG, "LoadAllJobs: Scanning %s...", RequestRoot);

  NumJobs = 0;

  if ((dir = cupsDirOpen(RequestRoot)) == NULL)
  {
    LogMessage(L_ERROR, "LoadAllJobs: Unable to open spool directory %s: %s",
               RequestRoot, strerror(errno));
    return;
  }

 /*
  * Read all the c##### files...
  */

  while ((dent = cupsDirRead(dir)) != NULL)
    if (strlen(dent->filename) >= 6 && dent->filename[0] == 'c')
    {
     /*
      * Allocate memory for the job...
      */

      if ((job = calloc(sizeof(job_t), 1)) == NULL)
      {
        LogMessage(L_ERROR, "LoadAllJobs: Ran out of memory for jobs!");
        cupsDirClose(dir);
        return;
      }

      if ((job->attrs = ippNew()) == NULL)
      {
        free(job);
        LogMessage(L_ERROR, "LoadAllJobs: Ran out of memory for job attributes!");
        cupsDirClose(dir);
        return;
      }

     /*
      * Assign the job ID...
      */

      job->id             = atoi(dent->filename + 1);
      job->back_pipes[0]  = -1;
      job->back_pipes[1]  = -1;
      job->print_pipes[0] = -1;
      job->print_pipes[1] = -1;

      LogMessage(L_DEBUG, "LoadAllJobs: Loading attributes for job %d...\n",
                 job->id);

      if (job->id >= NextJobId)
        NextJobId = job->id + 1;

     /*
      * Load the job control file...
      */

      snprintf(filename, sizeof(filename), "%s/%s", RequestRoot, dent->filename);
      if ((fd = open(filename, O_RDONLY)) < 0)
      {
        LogMessage(L_ERROR, "LoadAllJobs: Unable to open job control file \"%s\" - %s!",
                   filename, strerror(errno));
        ippDelete(job->attrs);
        free(job);
        unlink(filename);
        continue;
      }
      else
      {
        if (ippReadFile(fd, job->attrs) != IPP_DATA)
        {
          LogMessage(L_ERROR, "LoadAllJobs: Unable to read job control file \"%s\"!",
                     filename);
          close(fd);
          ippDelete(job->attrs);
          free(job);
          unlink(filename);
          continue;
        }

        close(fd);
      }

      if ((job->state = ippFindAttribute(job->attrs, "job-state", IPP_TAG_ENUM)) == NULL)
      {
        LogMessage(L_ERROR, "LoadAllJobs: Missing or bad job-state attribute in control file \"%s\"!",
                   filename);
        ippDelete(job->attrs);
        free(job);
        unlink(filename);
        continue;
      }

      if ((attr = ippFindAttribute(job->attrs, "job-printer-uri", IPP_TAG_URI)) == NULL)
      {
        LogMessage(L_ERROR, "LoadAllJobs: No job-printer-uri attribute in control file \"%s\"!",
                   filename);
        ippDelete(job->attrs);
        free(job);
        unlink(filename);
        continue;
      }

      httpSeparate(attr->values[0].string.text, method, username, host,
                   &port, resource);

      if ((dest = ValidateDest(host, resource, &(job->dtype), NULL)) == NULL &&
          job->state != NULL &&
          job->state->values[0].integer <= IPP_JOB_PROCESSING)
      {
       /*
        * Job queued on remote printer or class, so add it...
        */

        if (strncmp(resource, "/classes/", 9) == 0)
        {
          p = AddClass(resource + 9);
          SetString(&p->make_model, "Remote Class on unknown");
        }
        else
        {
          p = AddPrinter(resource + 10);
          SetString(&p->make_model, "Remote Printer on unknown");
        }

        p->state       = IPP_PRINTER_STOPPED;
        p->type        |= CUPS_PRINTER_REMOTE;
        p->browse_time = 2147483647;

        SetString(&p->location, "Location Unknown");
        SetString(&p->info, "No Information Available");
        p->hostname[0] = '\0';

        SetPrinterAttrs(p);
        dest = p->name;
      }

      if (dest == NULL)
      {
        LogMessage(L_ERROR, "LoadAllJobs: Unable to queue job for destination \"%s\"!",
                   attr->values[0].string.text);
        ippDelete(job->attrs);
        free(job);
        unlink(filename);
        continue;
      }

      SetString(&job->dest, dest);

      job->sheets     = ippFindAttribute(job->attrs, "job-media-sheets-completed",
                                         IPP_TAG_INTEGER);
      job->job_sheets = ippFindAttribute(job->attrs, "job-sheets", IPP_TAG_NAME);

      if ((attr = ippFindAttribute(job->attrs, "job-priority", IPP_TAG_INTEGER)) == NULL)
      {
        LogMessage(L_ERROR, "LoadAllJobs: Missing or bad job-priority attribute in control file \"%s\"!",
                   filename);
        ippDelete(job->attrs);
        free(job);
        unlink(filename);
        continue;
      }
      job->priority = attr->values[0].integer;

      if ((attr = ippFindAttribute(job->attrs, "job-originating-user-name", IPP_TAG_NAME)) == NULL)
      {
        LogMessage(L_ERROR, "LoadAllJobs: Missing or bad job-originating-user-name attribute in control file \"%s\"!",
                   filename);
        ippDelete(job->attrs);
        free(job);
        unlink(filename);
        continue;
      }
      SetString(&job->username, attr->values[0].string.text);

     /*
      * Insert the job into the array, sorting by job priority and ID...
      */

      for (current = Jobs, prev = NULL;
           current != NULL;
           prev = current, current = current->next)
        if (job->priority > current->priority)
          break;
        else if (job->priority == current->priority && job->id < current->id)
          break;

      job->next = current;
      if (prev != NULL)
        prev->next = job;
      else
        Jobs = job;

      NumJobs ++;

     /*
      * Set the job hold-until time and state...
      */

      if (job->state->values[0].integer == IPP_JOB_HELD)
      {
        if ((attr = ippFindAttribute(job->attrs, "job-hold-until", IPP_TAG_KEYWORD)) == NULL)
          attr = ippFindAttribute(job->attrs, "job-hold-until", IPP_TAG_NAME);

        if (attr == NULL)
          job->state->values[0].integer = IPP_JOB_PENDING;
        else
          SetJobHoldUntil(job->id, attr->values[0].string.text);
      }
      else if (job->state->values[0].integer == IPP_JOB_PROCESSING)
        job->state->values[0].integer = IPP_JOB_PENDING;
    }

 /*
  * Read all the d##### files...
  */

  cupsDirRewind(dir);

  while ((dent = cupsDirRead(dir)) != NULL)
    if (strlen(dent->filename) > 7 && dent->filename[0] == 'd' &&
        strchr(dent->filename, '-'))
    {
     /*
      * Find the job...
      */

      jobid  = atoi(dent->filename + 1);
      fileid = atoi(strchr(dent->filename, '-') + 1);

      LogMessage(L_DEBUG, "LoadAllJobs: Auto-typing document file %s...",
                 dent->filename);

      snprintf(filename, sizeof(filename), "%s/%s", RequestRoot, dent->filename);

      if ((job = FindJob(jobid)) == NULL)
      {
        LogMessage(L_ERROR, "LoadAllJobs: Orphaned print file \"%s\"!",
                   filename);
        unlink(filename);
        continue;
      }

      if (fileid > job->num_files)
      {
        if (job->num_files == 0)
        {
          compressions = (int *)calloc(fileid, sizeof(int));
          filetypes    = (mime_type_t **)calloc(fileid, sizeof(mime_type_t *));
        }
        else
        {
          compressions = (int *)realloc(job->compressions,
                                        sizeof(int) * fileid);
          filetypes    = (mime_type_t **)realloc(job->filetypes,
                                                 sizeof(mime_type_t *) * fileid);
        }

        if (compressions == NULL || filetypes == NULL)
        {
          LogMessage(L_ERROR, "LoadAllJobs: Ran out of memory for job file types!");
          continue;
        }

        job->compressions = compressions;
        job->filetypes    = filetypes;
        job->num_files    = fileid;
      }

      job->filetypes[fileid - 1] = mimeFileType(MimeDatabase, filename,
                                                job->compressions + fileid - 1);

      if (job->filetypes[fileid - 1] == NULL)
        job->filetypes[fileid - 1] = mimeType(MimeDatabase, "application",
                                              "vnd.cups-raw");
    }

  cupsDirClose(dir);

 /*
  * Clean out old jobs as needed...
  */

  CleanJobs();
}


/*
 * 'MoveJob()' - Move the specified job to a different destination.
 */

void
MoveJob(int        id,                  /* I - Job ID */
        const char *dest)               /* I - Destination */
{
  job_t                 *current;       /* Current job */
  ipp_attribute_t       *attr;          /* job-printer-uri attribute */
  printer_t             *p;             /* Destination printer or class */


  if ((p = FindPrinter(dest)) == NULL)
    p = FindClass(dest);

  if (p == NULL)
    return;

  for (current = Jobs; current != NULL; current = current->next)
    if (current->id == id)
    {
      if (current->state->values[0].integer >= IPP_JOB_PROCESSING)
        break;

      SetString(&current->dest, dest);
      current->dtype = p->type & (CUPS_PRINTER_CLASS | CUPS_PRINTER_REMOTE |
                                  CUPS_PRINTER_IMPLICIT);

      if ((attr = ippFindAttribute(current->attrs, "job-printer-uri", IPP_TAG_URI)) != NULL)
      {
        free(attr->values[0].string.text);
        attr->values[0].string.text = strdup(p->uri);
      }

      SaveJob(current->id);

      return;
    }
}


/*
 * 'ReleaseJob()' - Release the specified job.
 */

void
ReleaseJob(int id)                      /* I - Job ID */
{
  job_t *job;                           /* Job data */


  LogMessage(L_DEBUG, "ReleaseJob: id = %d", id);

  if ((job = FindJob(id)) == NULL)
    return;

  if (job->state->values[0].integer == IPP_JOB_HELD)
  {
    DEBUG_puts("ReleaseJob: setting state to pending...");

    job->state->values[0].integer = IPP_JOB_PENDING;
    SaveJob(id);
    CheckJobs();
  }
}


/*
 * 'RestartJob()' - Restart the specified job.
 */

void
RestartJob(int id)                      /* I - Job ID */
{
  job_t *job;                           /* Job data */


  if ((job = FindJob(id)) == NULL)
    return;

  if (job->state->values[0].integer == IPP_JOB_STOPPED || JobFiles)
  {
    job->tries = 0;
    job->state->values[0].integer = IPP_JOB_PENDING;
    SaveJob(id);
    CheckJobs();
  }
}


/*
 * 'SaveJob()' - Save a job to disk.
 */

void
SaveJob(int id)                         /* I - Job ID */
{
  job_t *job;                           /* Pointer to job */
  char  filename[1024];                 /* Job control filename */
  int   fd;                             /* File descriptor */


  if ((job = FindJob(id)) == NULL)
    return;

  snprintf(filename, sizeof(filename), "%s/c%05d", RequestRoot, id);

  if ((fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0600)) < 0)
  {
    LogMessage(L_ERROR, "SaveJob: Unable to create job control file \"%s\" - %s.",
               filename, strerror(errno));
    return;
  }

  fchmod(fd, 0600);
  fchown(fd, RunUser, Group);

  ippWriteFile(fd, job->attrs);

  LogMessage(L_DEBUG2, "SaveJob: Closing file %d...", fd);

  close(fd);
}


/*
 * 'SetJobHoldUntil()' - Set the hold time for a job...
 */

void
SetJobHoldUntil(int        id,          /* I - Job ID */
                const char *when)       /* I - When to resume */
{
  job_t         *job;                   /* Pointer to job */
  time_t        curtime;                /* Current time */
  struct tm     *curdate;               /* Current date */
  int           hour;                   /* Hold hour */
  int           minute;                 /* Hold minute */
  int           second;                 /* Hold second */


  LogMessage(L_DEBUG, "SetJobHoldUntil(%d, \"%s\")", id, when);

  if ((job = FindJob(id)) == NULL)
    return;

  second = 0;

  if (strcmp(when, "indefinite") == 0)
  {
   /*
    * Hold indefinitely...
    */

    job->hold_until = 0;
  }
  else if (strcmp(when, "day-time") == 0)
  {
   /*
    * Hold to 6am the next morning unless local time is < 6pm.
    */

    curtime = time(NULL);
    curdate = localtime(&curtime);

    if (curdate->tm_hour < 18)
      job->hold_until = curtime;
    else
      job->hold_until = curtime +
                        ((29 - curdate->tm_hour) * 60 + 59 -
                         curdate->tm_min) * 60 + 60 - curdate->tm_sec;
  }
  else if (strcmp(when, "evening") == 0 || strcmp(when, "night") == 0)
  {
   /*
    * Hold to 6pm unless local time is > 6pm or < 6am.
    */

    curtime = time(NULL);
    curdate = localtime(&curtime);

    if (curdate->tm_hour < 6 || curdate->tm_hour >= 18)
      job->hold_until = curtime;
    else
      job->hold_until = curtime +
                        ((17 - curdate->tm_hour) * 60 + 59 -
                         curdate->tm_min) * 60 + 60 - curdate->tm_sec;
  }  
  else if (strcmp(when, "second-shift") == 0)
  {
   /*
    * Hold to 4pm unless local time is > 4pm.
    */

    curtime = time(NULL);
    curdate = localtime(&curtime);

    if (curdate->tm_hour >= 16)
      job->hold_until = curtime;
    else
      job->hold_until = curtime +
                        ((15 - curdate->tm_hour) * 60 + 59 -
                         curdate->tm_min) * 60 + 60 - curdate->tm_sec;
  }  
  else if (strcmp(when, "third-shift") == 0)
  {
   /*
    * Hold to 12am unless local time is < 8am.
    */

    curtime = time(NULL);
    curdate = localtime(&curtime);

    if (curdate->tm_hour < 8)
      job->hold_until = curtime;
    else
      job->hold_until = curtime +
                        ((23 - curdate->tm_hour) * 60 + 59 -
                         curdate->tm_min) * 60 + 60 - curdate->tm_sec;
  }  
  else if (strcmp(when, "weekend") == 0)
  {
   /*
    * Hold to weekend unless we are in the weekend.
    */

    curtime = time(NULL);
    curdate = localtime(&curtime);

    if (curdate->tm_wday == 0 || curdate->tm_wday == 6)
      job->hold_until = curtime;
    else
      job->hold_until = curtime +
                        (((5 - curdate->tm_wday) * 24 +
                          (17 - curdate->tm_hour)) * 60 + 59 -
                           curdate->tm_min) * 60 + 60 - curdate->tm_sec;
  }
  else if (sscanf(when, "%d:%d:%d", &hour, &minute, &second) >= 2)
  {
   /*
    * Hold to specified GMT time (HH:MM or HH:MM:SS)...
    */

    curtime = time(NULL);
    curdate = gmtime(&curtime);

    job->hold_until = curtime +
                      ((hour - curdate->tm_hour) * 60 + minute -
                       curdate->tm_min) * 60 + second - curdate->tm_sec;

   /*
    * Hold until next day as needed...
    */

    if (job->hold_until < curtime)
      job->hold_until += 24 * 60 * 60 * 60;
  }

  LogMessage(L_DEBUG, "SetJobHoldUntil: hold_until = %d", (int)job->hold_until);
}


/*
 * 'SetJobPriority()' - Set the priority of a job, moving it up/down in the
 *                      list as needed.
 */

void
SetJobPriority(int id,                  /* I - Job ID */
               int priority)            /* I - New priority (0 to 100) */
{
  job_t         *job,                   /* Job to change */
                *current,               /* Current job */
                *prev;                  /* Previous job */
  ipp_attribute_t *attr;                /* Job attribute */


 /*
  * Find the job...
  */

  for (current = Jobs, prev = NULL;
       current != NULL;
       prev = current, current = current->next)
    if (current->id == id)
      break;

  if (current == NULL)
    return;

 /*
  * Set the new priority...
  */

  job = current;
  job->priority = priority;

  if ((attr = ippFindAttribute(job->attrs, "job-priority", IPP_TAG_INTEGER)) != NULL)
    attr->values[0].integer = priority;
  else
    ippAddInteger(job->attrs, IPP_TAG_JOB, IPP_TAG_INTEGER, "job-priority",
                  priority);

  SaveJob(job->id);

 /*
  * See if we need to do any sorting...
  */

  if ((prev == NULL || job->priority < prev->priority) &&
      (job->next == NULL || job->next->priority < job->priority))
    return;

 /*
  * Remove the job from the list, and then insert it where it belongs...
  */

  if (prev == NULL)
    Jobs = job->next;
  else
    prev->next = job->next;

  for (current = Jobs, prev = NULL;
       current != NULL;
       prev = current, current = current->next)
    if (job->priority > current->priority)
      break;

  job->next = current;
  if (prev != NULL)
    prev->next = job;
  else
    Jobs = job;
}


/*
 * 'StartJob()' - Start a print job.
 */

void
StartJob(int       id,                  /* I - Job ID */
         printer_t *printer)            /* I - Printer to print job */
{
  job_t         *current;               /* Current job */
  int           i;                      /* Looping var */
  int           slot;                   /* Pipe slot */
  int           num_filters;            /* Number of filters for job */
  mime_filter_t *filters;               /* Filters for job */
  char          method[255],            /* Method for output */
                *optptr,                /* Pointer to options */
                *valptr;                /* Pointer in value string */
  ipp_attribute_t *attr;                /* Current attribute */
  int           pid;                    /* Process ID of new filter process */
  int           banner_page;            /* 1 if banner page, 0 otherwise */
  int           statusfds[2],           /* Pipes used between the filters and scheduler */
                filterfds[2][2];        /* Pipes used between the filters */
  int           envc;                   /* Number of environment variables */
  char          *argv[8],               /* Filter command-line arguments */
                sani_uri[1024],         /* Sanitized DEVICE_URI env var */
                filename[1024],         /* Job filename */
                command[1024],          /* Full path to filter/backend command */
                jobid[255],             /* Job ID string */
                title[IPP_MAX_NAME],    /* Job title string */
                copies[255],            /* # copies string */
                *envp[100],             /* Environment variables */
                charset[255],           /* CHARSET environment variable */
                class_name[255],        /* CLASS environment variable */
                classification[1024],   /* CLASSIFICATION environment variable */
                content_type[1024],     /* CONTENT_TYPE environment variable */
                device_uri[1024],       /* DEVICE_URI environment variable */
                lang[255],              /* LANG environment variable */
                ppd[1024],              /* PPD environment variable */
                printer_name[255],      /* PRINTER environment variable */
                rip_max_cache[255];     /* RIP_MAX_CACHE environment variable */
  static char   *options = NULL;        /* Full list of options */
  static int    optlength = 0;          /* Length of option buffer */


  LogMessage(L_DEBUG, "StartJob(%d, %p)", id, printer);

  for (current = Jobs; current != NULL; current = current->next)
    if (current->id == id)
      break;

  if (current == NULL)
    return;

  LogMessage(L_DEBUG, "StartJob() id = %d, file = %d/%d", id,
             current->current_file, current->num_files);

  if (current->num_files == 0)
  {
    LogMessage(L_ERROR, "Job ID %d has no files!  Cancelling it!", id);

    cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, current->printer, current,
                  "Job cancelled because it has no files.");

    CancelJob(id, 0);
    return;
  }

 /*
  * Figure out what filters are required to convert from
  * the source to the destination type...
  */

  num_filters   = 0;
  current->cost = 0;

  if (printer->raw)
  {
   /*
    * Remote jobs and raw queues go directly to the printer without
    * filtering...
    */

    LogMessage(L_DEBUG, "StartJob: Sending job to queue tagged as raw...");

    filters = NULL;
  }
  else
  {
   /*
    * Local jobs get filtered...
    */

    filters = mimeFilter(MimeDatabase, current->filetypes[current->current_file],
                         printer->filetype, &num_filters, MAX_FILTERS - 1);

    if (num_filters == 0)
    {
      LogMessage(L_ERROR, "Unable to convert file %d to printable format for job %d!",
                 current->current_file, current->id);
      LogMessage(L_INFO, "Hint: Do you have ESP Ghostscript installed?");

      if (LogLevel < L_DEBUG)
        LogMessage(L_INFO, "Hint: Try setting the LogLevel to \"debug\".");

      current->current_file ++;

      if (current->current_file == current->num_files)
      {
        cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, current->printer, current,
                      "Job cancelled because it has no files that can be printed.");

        CancelJob(current->id, 0);
      }

      return;
    }

   /*
    * Remove NULL ("-") filters...
    */

    for (i = 0; i < num_filters;)
      if (strcmp(filters[i].filter, "-") == 0)
      {
        num_filters --;
        if (i < num_filters)
          memcpy(filters + i, filters + i + 1,
                 (num_filters - i) * sizeof(mime_filter_t));
      }
      else
        i ++;

    if (num_filters == 0)
    {
      free(filters);
      filters = NULL;
    }
    else
    {
     /*
      * Compute filter cost...
      */

      for (i = 0; i < num_filters; i ++)
        current->cost += filters[i].cost;
    }
  }

 /*
  * See if the filter cost is too high...
  */

  if ((FilterLevel + current->cost) > FilterLimit && FilterLevel > 0 &&
      FilterLimit > 0)
  {
   /*
    * Don't print this job quite yet...
    */

    if (filters != NULL)
      free(filters);

    LogMessage(L_INFO, "Holding job %d because filter limit has been reached.",
               id);
    LogMessage(L_DEBUG, "StartJob: id = %d, file = %d, "
                        "cost = %d, level = %d, limit = %d",
               id, current->current_file, current->cost, FilterLevel,
               FilterLimit);
    return;
  }

  FilterLevel += current->cost;

 /*
  * Add decompression filters, if any...
  */

  if (current->compressions[current->current_file])
  {
   /*
    * Add gziptoany filter to the front of the list...
    */

    mime_filter_t       *temp_filters;

    if (num_filters == 0)
      temp_filters = malloc(sizeof(mime_filter_t));
    else
      temp_filters = realloc(filters,
                             sizeof(mime_filter_t) * (num_filters + 1));

    if (temp_filters == NULL)
    {
      LogMessage(L_ERROR, "Unable to add decompression filter - %s",
                 strerror(errno));

      if (filters != NULL)
        free(filters);

      current->current_file ++;

      if (current->current_file == current->num_files)
      {
        cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, current->printer, current,
                      "Job cancelled because the print file could not be decompressed.");

        CancelJob(current->id, 0);
      }

      return;
    }

    filters = temp_filters;
    memmove(filters + 1, filters, num_filters * sizeof(mime_filter_t));
    *filters = gziptoany_filter;
    num_filters ++;
  }

 /*
  * Add port monitor, if any...
  */

  if (printer->port_monitor)
  {
   /*
    * Add port monitor to the end of the list...
    */

    mime_filter_t       *temp_filters;

    if (num_filters == 0)
      temp_filters = malloc(sizeof(mime_filter_t));
    else
      temp_filters = realloc(filters,
                             sizeof(mime_filter_t) * (num_filters + 1));

    if (temp_filters == NULL)
    {
      LogMessage(L_ERROR, "Unable to add port monitor - %s",
                 strerror(errno));

      if (filters != NULL)
        free(filters);

      current->current_file ++;

      if (current->current_file == current->num_files)
      {
        cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, current->printer, current,
                      "Job cancelled because the port monitor could not be added.");

        CancelJob(current->id, 0);
      }

      return;
    }

    filters = temp_filters;
    memset(filters + num_filters, 0, sizeof(mime_filter_t));
    snprintf(filters[num_filters].filter, sizeof(filters[num_filters].filter),
             "%s/monitor/%s", ServerBin, printer->port_monitor);
    num_filters ++;
  }

 /*
  * Update the printer and job state to "processing"...
  */

  current->state->values[0].integer = IPP_JOB_PROCESSING;
  current->status  = 0;
  current->printer = printer;
  printer->job     = current;
  SetPrinterState(printer, IPP_PRINTER_PROCESSING, 0);

  if (current->current_file == 0)
  {
    set_time(current, "time-at-processing");
    cupsdOpenPipe(current->back_pipes);
  }

 /*
  * Determine if we are printing a banner page or not...
  */

  if (current->job_sheets == NULL)
  {
    LogMessage(L_DEBUG, "No job-sheets attribute.");
    if ((current->job_sheets =
         ippFindAttribute(current->attrs, "job-sheets", IPP_TAG_ZERO)) != NULL)
      LogMessage(L_DEBUG, "... but someone added one without setting job_sheets!");
  }
  else if (current->job_sheets->num_values == 1)
    LogMessage(L_DEBUG, "job-sheets=%s",
               current->job_sheets->values[0].string.text);
  else
    LogMessage(L_DEBUG, "job-sheets=%s,%s",
               current->job_sheets->values[0].string.text,
               current->job_sheets->values[1].string.text);

  if (printer->type & (CUPS_PRINTER_REMOTE | CUPS_PRINTER_IMPLICIT))
    banner_page = 0;
  else if (current->job_sheets == NULL)
    banner_page = 0;
  else if (strcasecmp(current->job_sheets->values[0].string.text, "none") != 0 &&
           current->current_file == 0)
    banner_page = 1;
  else if (current->job_sheets->num_values > 1 &&
           strcasecmp(current->job_sheets->values[1].string.text, "none") != 0 &&
           current->current_file == (current->num_files - 1))
    banner_page = 1;
  else
    banner_page = 0;

  LogMessage(L_DEBUG, "banner_page = %d", banner_page);

 /*
  * Building the options string is harder than it needs to be, but
  * for the moment we need to pass strings for command-line args and
  * not IPP attribute pointers... :)
  *
  * First allocate/reallocate the option buffer as needed...
  */

  i = ipp_length(current->attrs);

  if (i > optlength)
  {
    if (optlength == 0)
      optptr = malloc(i);
    else
      optptr = realloc(options, i);

    if (optptr == NULL)
    {
      LogMessage(L_CRIT, "StartJob: Unable to allocate %d bytes for option buffer for job %d!",
                 i, id);

      if (filters != NULL)
        free(filters);

      FilterLevel -= current->cost;

      cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, current->printer, current,
                    "Job cancelled because the server ran out of memory.");

      CancelJob(id, 0);
      return;
    }

    options   = optptr;
    optlength = i;
  }

 /*
  * Now loop through the attributes and convert them to the textual
  * representation used by the filters...
  */

  optptr  = options;
  *optptr = '\0';

  snprintf(title, sizeof(title), "%s-%d", printer->name, current->id);
  strcpy(copies, "1");

  for (attr = current->attrs->attrs; attr != NULL; attr = attr->next)
  {
    if (strcmp(attr->name, "copies") == 0 &&
        attr->value_tag == IPP_TAG_INTEGER)
    {
     /*
      * Don't use the # copies attribute if we are printing the job sheets...
      */

      if (!banner_page)
        sprintf(copies, "%d", attr->values[0].integer);
    }
    else if (strcmp(attr->name, "job-name") == 0 &&
             (attr->value_tag == IPP_TAG_NAME ||
              attr->value_tag == IPP_TAG_NAMELANG))
      strlcpy(title, attr->values[0].string.text, sizeof(title));
    else if (attr->group_tag == IPP_TAG_JOB)
    {
     /*
      * Filter out other unwanted attributes...
      */

      if (attr->value_tag == IPP_TAG_MIMETYPE ||
          attr->value_tag == IPP_TAG_NAMELANG ||
          attr->value_tag == IPP_TAG_TEXTLANG ||
          attr->value_tag == IPP_TAG_URI ||
          attr->value_tag == IPP_TAG_URISCHEME ||
          attr->value_tag == IPP_TAG_BEGIN_COLLECTION) /* Not yet supported */
        continue;

      if (strncmp(attr->name, "time-", 5) == 0)
        continue;

      if (strncmp(attr->name, "job-", 4) == 0 &&
          !(printer->type & CUPS_PRINTER_REMOTE))
        continue;

      if (strncmp(attr->name, "job-", 4) == 0 &&
          strcmp(attr->name, "job-billing") != 0 &&
          strcmp(attr->name, "job-sheets") != 0 &&
          strcmp(attr->name, "job-hold-until") != 0 &&
          strcmp(attr->name, "job-priority") != 0)
        continue;

      if ((strcmp(attr->name, "page-label") == 0 ||
           strcmp(attr->name, "page-border") == 0 ||
           strncmp(attr->name, "number-up", 9) == 0 ||
           strcmp(attr->name, "page-set") == 0) &&
          banner_page)
        continue;

     /*
      * Otherwise add them to the list...
      */

      if (optptr > options)
        strlcat(optptr, " ", optlength - (optptr - options));

      if (attr->value_tag != IPP_TAG_BOOLEAN)
      {
        strlcat(optptr, attr->name, optlength - (optptr - options));
        strlcat(optptr, "=", optlength - (optptr - options));
      }

      for (i = 0; i < attr->num_values; i ++)
      {
        if (i)
          strlcat(optptr, ",", optlength - (optptr - options));

        optptr += strlen(optptr);

        switch (attr->value_tag)
        {
          case IPP_TAG_INTEGER :
          case IPP_TAG_ENUM :
              snprintf(optptr, optlength - (optptr - options),
                       "%d", attr->values[i].integer);
              break;

          case IPP_TAG_BOOLEAN :
              if (!attr->values[i].boolean)
                strlcat(optptr, "no", optlength - (optptr - options));

          case IPP_TAG_NOVALUE :
              strlcat(optptr, attr->name,
                      optlength - (optptr - options));
              break;

          case IPP_TAG_RANGE :
              if (attr->values[i].range.lower == attr->values[i].range.upper)
                snprintf(optptr, optlength - (optptr - options) - 1,
                         "%d", attr->values[i].range.lower);
              else
                snprintf(optptr, optlength - (optptr - options) - 1,
                         "%d-%d", attr->values[i].range.lower,
                         attr->values[i].range.upper);
              break;

          case IPP_TAG_RESOLUTION :
              snprintf(optptr, optlength - (optptr - options) - 1,
                       "%dx%d%s", attr->values[i].resolution.xres,
                       attr->values[i].resolution.yres,
                       attr->values[i].resolution.units == IPP_RES_PER_INCH ?
                           "dpi" : "dpc");
              break;

          case IPP_TAG_STRING :
          case IPP_TAG_TEXT :
          case IPP_TAG_NAME :
          case IPP_TAG_KEYWORD :
          case IPP_TAG_CHARSET :
          case IPP_TAG_LANGUAGE :
              for (valptr = attr->values[i].string.text; *valptr;)
              {
                if (strchr(" \t\n\\\'\"", *valptr))
                  *optptr++ = '\\';
                *optptr++ = *valptr++;
              }

              *optptr = '\0';
              break;

          default :
              break; /* anti-compiler-warning-code */
        }
      }

      optptr += strlen(optptr);
    }
  }

 /*
  * Build the command-line arguments for the filters.  Each filter
  * has 6 or 7 arguments:
  *
  *     argv[0] = printer
  *     argv[1] = job ID
  *     argv[2] = username
  *     argv[3] = title
  *     argv[4] = # copies
  *     argv[5] = options
  *     argv[6] = filename (optional; normally stdin)
  *
  * This allows legacy printer drivers that use the old System V
  * printing interface to be used by CUPS.
  */

  sprintf(jobid, "%d", current->id);
  snprintf(filename, sizeof(filename), "%s/d%05d-%03d", RequestRoot,
           current->id, current->current_file + 1);

  argv[0] = printer->name;
  argv[1] = jobid;
  argv[2] = current->username;
  argv[3] = title;
  argv[4] = copies;
  argv[5] = options;
  argv[6] = filename;
  argv[7] = NULL;

  LogMessage(L_DEBUG, "StartJob: argv = \"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"%s\"",
             argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6]);

 /*
  * Create environment variable strings for the filters...
  */

  attr = ippFindAttribute(current->attrs, "attributes-natural-language",
                          IPP_TAG_LANGUAGE);

  switch (strlen(attr->values[0].string.text))
  {
    default :
       /*
        * This is an unknown or badly formatted language code; use
        * the POSIX locale...
        */

        strcpy(lang, "LANG=C");
        break;

    case 2 :
       /*
        * Just the language code (ll)...
        */

        snprintf(lang, sizeof(lang), "LANG=%s",
                 attr->values[0].string.text);
        break;

    case 5 :
       /*
        * Language and country code (ll-cc)...
        */

        snprintf(lang, sizeof(lang), "LANG=%c%c_%c%c",
                 attr->values[0].string.text[0],
                 attr->values[0].string.text[1],
                 toupper(attr->values[0].string.text[3] & 255),
                 toupper(attr->values[0].string.text[4] & 255));
        break;
  }

  attr = ippFindAttribute(current->attrs, "document-format",
                          IPP_TAG_MIMETYPE);
  if (attr != NULL &&
      (optptr = strstr(attr->values[0].string.text, "charset=")) != NULL)
    snprintf(charset, sizeof(charset), "CHARSET=%s", optptr + 8);
  else
  {
    attr = ippFindAttribute(current->attrs, "attributes-charset",
                            IPP_TAG_CHARSET);
    snprintf(charset, sizeof(charset), "CHARSET=%s",
             attr->values[0].string.text);
  }

  snprintf(content_type, sizeof(content_type), "CONTENT_TYPE=%s/%s",
           current->filetypes[current->current_file]->super,
           current->filetypes[current->current_file]->type);
  snprintf(device_uri, sizeof(device_uri), "DEVICE_URI=%s", printer->device_uri);
  cupsdSanitizeURI(printer->device_uri, sani_uri, sizeof(sani_uri));
  snprintf(ppd, sizeof(ppd), "PPD=%s/ppd/%s.ppd", ServerRoot, printer->name);
  snprintf(printer_name, sizeof(printer_name), "PRINTER=%s", printer->name);
  snprintf(rip_max_cache, sizeof(rip_max_cache), "RIP_MAX_CACHE=%s", RIPCache);

  envc = cupsdLoadEnv(envp, (int)(sizeof(envp) / sizeof(envp[0])));

  envp[envc ++] = charset;
  envp[envc ++] = lang;
  envp[envc ++] = ppd;
  envp[envc ++] = rip_max_cache;
  envp[envc ++] = content_type;
  envp[envc ++] = device_uri;
  envp[envc ++] = printer_name;

  if (Classification && !banner_page)
  {
    if ((attr = ippFindAttribute(current->attrs, "job-sheets",
                                 IPP_TAG_NAME)) == NULL)
      snprintf(classification, sizeof(classification), "CLASSIFICATION=%s",
               Classification);
    else if (attr->num_values > 1 &&
             strcmp(attr->values[1].string.text, "none") != 0)
      snprintf(classification, sizeof(classification), "CLASSIFICATION=%s",
               attr->values[1].string.text);
    else
      snprintf(classification, sizeof(classification), "CLASSIFICATION=%s",
               attr->values[0].string.text);

    envp[envc ++] = classification;
  }

  if (current->dtype & (CUPS_PRINTER_CLASS | CUPS_PRINTER_IMPLICIT))
  {
    snprintf(class_name, sizeof(class_name), "CLASS=%s", current->dest);
    envp[envc ++] = class_name;
  }

  envp[envc] = NULL;

  for (i = 0; i < envc; i ++)
    if (strncmp(envp[i], "DEVICE_URI=", 11))
      LogMessage(L_DEBUG, "StartJob: envp[%d]=\"%s\"", i, envp[i]);
    else
      LogMessage(L_DEBUG, "StartJob: envp[%d]=\"DEVICE_URI=%s\"", i, sani_uri);

  current->current_file ++;

 /*
  * Now create processes for all of the filters...
  */

  if (cupsdOpenPipe(statusfds))
  {
    LogMessage(L_ERROR, "Unable to create job status pipes - %s.",
               strerror(errno));
    snprintf(printer->state_message, sizeof(printer->state_message),
             "Unable to create status pipes - %s.", strerror(errno));

    AddPrinterHistory(printer);

    if (filters != NULL)
      free(filters);

    cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, current->printer, current,
                  "Job cancelled because the server could not create the job status pipes.");

    CancelJob(current->id, 0);
    return;
  }

  LogMessage(L_DEBUG, "StartJob: statusfds = [ %d %d ]",
             statusfds[0], statusfds[1]);

#ifdef FD_CLOEXEC
  fcntl(statusfds[0], F_SETFD, FD_CLOEXEC);
  fcntl(statusfds[1], F_SETFD, FD_CLOEXEC);
#endif /* FD_CLOEXEC */

  current->status_buffer = cupsdStatBufNew(statusfds[0], "[Job %d]",
                                           current->id);
  current->status        = 0;
  memset(current->filters, 0, sizeof(current->filters));

  filterfds[1][0] = open("/dev/null", O_RDONLY);
  filterfds[1][1] = -1;

  if (filterfds[1][0] < 0)
  {
    LogMessage(L_ERROR, "Unable to open \"/dev/null\" - %s.", strerror(errno));
    snprintf(printer->state_message, sizeof(printer->state_message),
             "Unable to open \"/dev/null\" - %s.", strerror(errno));

    AddPrinterHistory(printer);

    if (filters != NULL)
      free(filters);

    cupsdClosePipe(statusfds);
    CancelJob(current->id, 0);
    return;
  }

  fcntl(filterfds[1][0], F_SETFD, fcntl(filterfds[1][0], F_GETFD) | FD_CLOEXEC);

  LogMessage(L_DEBUG, "StartJob: filterfds[%d] = [ %d %d ]", 1, filterfds[1][0],
             filterfds[1][1]);

  for (i = 0, slot = 0; i < num_filters; i ++)
  {
    if (filters[i].filter[0] != '/')
      snprintf(command, sizeof(command), "%s/filter/%s", ServerBin,
               filters[i].filter);
    else
      strlcpy(command, filters[i].filter, sizeof(command));

#ifdef __APPLE__
   /*
    * Setting CFProcessPath lets OS X's Core Foundation code find
    * the bundle that may be associated with a filter or backend.
    */

    snprintf(processPath, sizeof(processPath), "CFProcessPath=%s", command);
    LogMessage(L_DEBUG, "StartJob: %s\n", processPath);
#endif  /* __APPLE__ */

    if (i < (num_filters - 1))
    {
      if (cupsdOpenPipe(filterfds[slot]))
      {
        LogMessage(L_ERROR, "Unable to create job filter pipes - %s.",
                strerror(errno));
        snprintf(printer->state_message, sizeof(printer->state_message),
                "Unable to create filter pipes - %s.", strerror(errno));
        AddPrinterHistory(printer);

        if (filters != NULL)
          free(filters);

        cupsdClosePipe(statusfds);
        cupsdClosePipe(filterfds[!slot]);

        cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, current->printer, current,
                      "Job cancelled because the server could not create the filter pipes.");

        CancelJob(current->id, 0);
        return;
      }
    }
    else
    {
      if (current->current_file == 1)
      {
        if (strncmp(printer->device_uri, "file:", 5) != 0)
        {
          if (cupsdOpenPipe(current->print_pipes))
          {
            LogMessage(L_ERROR, "Unable to create job backend pipes - %s.",
                       strerror(errno));
            snprintf(printer->state_message, sizeof(printer->state_message),
                    "Unable to create backend pipes - %s.", strerror(errno));
            AddPrinterHistory(printer);

            if (filters != NULL)
              free(filters);

            cupsdClosePipe(statusfds);
            cupsdClosePipe(filterfds[!slot]);

            cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, current->printer, current,
                          "Job cancelled because the server could not create the backend pipes.");

            CancelJob(current->id, 0);
            return;
          }
        }
        else
        {
          current->print_pipes[0] = -1;
          if (!strncmp(printer->device_uri, "file:/dev/", 10) &&
              strcmp(printer->device_uri, "file:/dev/null"))
            current->print_pipes[1] = open(printer->device_uri + 5,
                                           O_WRONLY | O_EXCL);
          else if (!strncmp(printer->device_uri, "file:///dev/", 12) &&
                   strcmp(printer->device_uri, "file:///dev/null"))
            current->print_pipes[1] = open(printer->device_uri + 7,
                                           O_WRONLY | O_EXCL);
          else
            current->print_pipes[1] = open(printer->device_uri + 5,
                                           O_WRONLY | O_CREAT | O_TRUNC, 0600);

          if (current->print_pipes[1] < 0)
          {
            LogMessage(L_ERROR, "Unable to open output file \"%s\" - %s.",
                       printer->device_uri, strerror(errno));
            snprintf(printer->state_message, sizeof(printer->state_message),
                     "Unable to open output file \"%s\" - %s.",
                     printer->device_uri, strerror(errno));

            AddPrinterHistory(printer);

            if (filters != NULL)
              free(filters);

            cupsdClosePipe(statusfds);
            cupsdClosePipe(filterfds[!slot]);

            cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, current->printer, current,
                          "Job cancelled because the server could not open the output file.");

            CancelJob(current->id, 0);
            return;
          }

          fcntl(current->print_pipes[1], F_SETFD,
                fcntl(current->print_pipes[1], F_GETFD) | FD_CLOEXEC);
        }

        LogMessage(L_DEBUG2, "StartJob: print_pipes = [ %d %d ]",
                   current->print_pipes[0], current->print_pipes[1]);
      }

      filterfds[slot][0] = current->print_pipes[0];
      filterfds[slot][1] = current->print_pipes[1];
    }

    LogMessage(L_DEBUG, "StartJob: filter = \"%s\"", command);
    LogMessage(L_DEBUG, "StartJob: filterfds[%d] = [ %d %d ]",
               slot, filterfds[slot][0], filterfds[slot][1]);

    pid = cupsdStartProcess(command, argv, envp, filterfds[!slot][0],
                            filterfds[slot][1], statusfds[1],
                            current->back_pipes[0], 0, current->filters + i);

    LogMessage(L_DEBUG2, "StartJob: Closing filter pipes for slot %d [ %d %d ]...",
               !slot, filterfds[!slot][0], filterfds[!slot][1]);

    cupsdClosePipe(filterfds[!slot]);

    if (pid == 0)
    {
      LogMessage(L_ERROR, "Unable to start filter \"%s\" - %s.",
                 filters[i].filter, strerror(errno));
      snprintf(printer->state_message, sizeof(printer->state_message),
               "Unable to start filter \"%s\" - %s.",
               filters[i].filter, strerror(errno));

      AddPrinterHistory(printer);

      if (filters != NULL)
        free(filters);

      AddPrinterHistory(printer);

      cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, current->printer, current,
                    "Job cancelled because the server could not execute a filter.");

      CancelJob(current->id, 0);
      return;
    }

    LogMessage(L_INFO, "Started filter %s (PID %d) for job %d.",
               command, pid, current->id);

    argv[6] = NULL;
    slot    = !slot;
  }

  if (filters != NULL)
    free(filters);

 /*
  * Finally, pipe the final output into a backend process if needed...
  */

  if (strncmp(printer->device_uri, "file:", 5) != 0)
  {
    if (current->current_file == 1)
    {
      sscanf(printer->device_uri, "%254[^:]", method);
      snprintf(command, sizeof(command), "%s/backend/%s", ServerBin, method);

#ifdef __APPLE__
     /*
      * Setting CFProcessPath lets OS X's Core Foundation code find
      * the bundle that may be associated with a filter or backend.
      */

      snprintf(processPath, sizeof(processPath), "CFProcessPath=%s", command);
      LogMessage(L_DEBUG, "StartJob: %s\n", processPath);
#endif  /* __APPLE__ */

      argv[0] = sani_uri;

      filterfds[slot][0] = -1;
      filterfds[slot][1] = open("/dev/null", O_WRONLY);

      if (filterfds[slot][1] < 0)
      {
        LogMessage(L_ERROR, "Unable to open \"/dev/null\" - %s.", strerror(errno));
        snprintf(printer->state_message, sizeof(printer->state_message),
                 "Unable to open \"/dev/null\" - %s.", strerror(errno));

        AddPrinterHistory(printer);

        if (filters != NULL)
          free(filters);

        cupsdClosePipe(statusfds);

        cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, current->printer, current,
                      "Job cancelled because the server could not open a file.");

        CancelJob(current->id, 0);
        return;
      }

      fcntl(filterfds[slot][1], F_SETFD,
            fcntl(filterfds[slot][1], F_GETFD) | FD_CLOEXEC);

      LogMessage(L_DEBUG, "StartJob: backend = \"%s\"", command);
      LogMessage(L_DEBUG, "StartJob: filterfds[%d] = [ %d %d ]",
                 slot, filterfds[slot][0], filterfds[slot][1]);

      pid = cupsdStartProcess(command, argv, envp, filterfds[!slot][0],
                              filterfds[slot][1], statusfds[1],
                              current->back_pipes[1], 1,
                              &(current->backend));

      if (pid == 0)
      {
        LogMessage(L_ERROR, "Unable to start backend \"%s\" - %s.",
                   method, strerror(errno));
        snprintf(printer->state_message, sizeof(printer->state_message),
                 "Unable to start backend \"%s\" - %s.", method, strerror(errno));

        LogMessage(L_DEBUG2, "StartJob: Closing print pipes [ %d %d ]...",
                   current->print_pipes[0], current->print_pipes[1]);

        cupsdClosePipe(current->print_pipes);

        LogMessage(L_DEBUG2, "StartJob: Closing back pipes [ %d %d ]...",
                   current->back_pipes[0], current->back_pipes[1]);

        cupsdClosePipe(current->back_pipes);

        cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, current->printer, current,
                      "Job cancelled because the server could not execute the backend.");

        CancelJob(current->id, 0);
        return;
      }
      else
      {
        LogMessage(L_INFO, "Started backend %s (PID %d) for job %d.",
                   command, pid, current->id);
      }
    }

    if (current->current_file == current->num_files)
    {
      LogMessage(L_DEBUG2, "StartJob: Closing print pipes [ %d %d ]...",
                 current->print_pipes[0], current->print_pipes[1]);

      cupsdClosePipe(current->print_pipes);

      LogMessage(L_DEBUG2, "StartJob: Closing back pipes [ %d %d ]...",
                 current->back_pipes[0], current->back_pipes[1]);

      cupsdClosePipe(current->back_pipes);
    }
  }
  else
  {
    filterfds[slot][0] = -1;
    filterfds[slot][1] = -1;

    if (current->current_file == current->num_files)
    {
      LogMessage(L_DEBUG2, "StartJob: Closing print pipes [ %d %d ]...",
                 current->print_pipes[0], current->print_pipes[1]);

      cupsdClosePipe(current->print_pipes);
    }
  }

  LogMessage(L_DEBUG2, "StartJob: Closing filter pipes for slot %d [ %d %d ]...",
             slot, filterfds[slot][0], filterfds[slot][1]);

  cupsdClosePipe(filterfds[slot]);

  LogMessage(L_DEBUG2, "StartJob: Closing status output pipe %d...",
             statusfds[1]);

  close(statusfds[1]);

  LogMessage(L_DEBUG2, "StartJob: Adding fd %d to InputSet...",
             current->status_buffer->fd);

  FD_SET(current->status_buffer->fd, InputSet);
}


/*
 * 'StopAllJobs()' - Stop all print jobs.
 */

void
StopAllJobs(void)
{
  job_t *current;                       /* Current job */


  DEBUG_puts("StopAllJobs()");

  for (current = Jobs; current != NULL; current = current->next)
    if (current->state->values[0].integer == IPP_JOB_PROCESSING)
    {
      StopJob(current->id, 1);
      current->state->values[0].integer = IPP_JOB_PENDING;
    }
}


/*
 * 'StopJob()' - Stop a print job.
 */

void
StopJob(int id,                         /* I - Job ID */
        int force)                      /* I - 1 = Force all filters to stop */
{
  int   i;                              /* Looping var */
  job_t *current;                       /* Current job */


  LogMessage(L_DEBUG, "StopJob: id = %d, force = %d", id, force);

  for (current = Jobs; current != NULL; current = current->next)
    if (current->id == id)
    {
      DEBUG_puts("StopJob: found job in list.");

      if (current->state->values[0].integer == IPP_JOB_PROCESSING)
      {
        DEBUG_puts("StopJob: job state is \'processing\'.");

        FilterLevel -= current->cost;

        if (current->status < 0 &&
            !(current->dtype & (CUPS_PRINTER_CLASS | CUPS_PRINTER_IMPLICIT)) &&
            !(current->printer->type & CUPS_PRINTER_FAX) &&
            !strcmp(current->printer->error_policy, "stop-printer"))
          SetPrinterState(current->printer, IPP_PRINTER_STOPPED, 1);
        else if (current->printer->state != IPP_PRINTER_STOPPED)
          SetPrinterState(current->printer, IPP_PRINTER_IDLE, 0);

        LogMessage(L_DEBUG, "StopJob: printer state is %d", current->printer->state);

        current->state->values[0].integer = IPP_JOB_STOPPED;
        current->printer->job = NULL;
        current->printer      = NULL;

        current->current_file --;

        for (i = 0; current->filters[i]; i ++)
          if (current->filters[i] > 0)
          {
            cupsdEndProcess(current->filters[i], force);
            current->filters[i] = 0;
          }

        if (current->backend > 0)
        {
          cupsdEndProcess(current->backend, force);
          current->backend = 0;
        }

        LogMessage(L_DEBUG2, "StopJob: Closing print pipes [ %d %d ]...",
                   current->print_pipes[0], current->print_pipes[1]);

        cupsdClosePipe(current->print_pipes);

        LogMessage(L_DEBUG2, "StopJob: Closing back pipes [ %d %d ]...",
                   current->back_pipes[0], current->back_pipes[1]);

        cupsdClosePipe(current->back_pipes);

        if (current->status_buffer)
        {
         /*
          * Close the pipe and clear the input bit.
          */

          LogMessage(L_DEBUG2, "StopJob: Removing fd %d from InputSet...",
                     current->status_buffer->fd);

          FD_CLR(current->status_buffer->fd, InputSet);

          LogMessage(L_DEBUG2, "StopJob: Closing status input pipe %d...",
                     current->status_buffer->fd);

          cupsdStatBufDelete(current->status_buffer);

          current->status_buffer = NULL;
        }
      }
      return;
    }
}


/*
 * 'UpdateJob()' - Read a status update from a job's filters.
 */

void
UpdateJob(job_t *job)                   /* I - Job to check */
{
  int           i;                      /* Looping var */
  int           copies;                 /* Number of copies printed */
  char          message[1024],          /* Message text */
                *ptr;                   /* Pointer update... */
  int           loglevel;               /* Log level for message */


  while ((ptr = cupsdStatBufUpdate(job->status_buffer, &loglevel,
                                   message, sizeof(message))) != NULL)
  {
   /*
    * Process page and printer state messages as needed...
    */

    if (loglevel == L_PAGE)
    {
     /*
      * Page message; send the message to the page_log file and update the
      * job sheet count...
      */

      if (job->sheets != NULL)
      {
        if (!strncasecmp(message, "total ", 6))
        {
         /*
          * Got a total count of pages from a backend or filter...
          */

          copies = atoi(message + 6);
          copies -= job->sheets->values[0].integer; /* Just track the delta */
        }
        else if (!sscanf(message, "%*d%d", &copies))
          copies = 1;
          
        job->sheets->values[0].integer += copies;

        if (job->printer->page_limit)
          UpdateQuota(job->printer, job->username, copies, 0);
      }

      LogPage(job, message);

      cupsdAddEvent(CUPSD_EVENT_JOB_PROGRESS, job->printer, job,
                    "Printed %d page(s).", job->sheets->values[0].integer);
    }
    else if (loglevel == L_STATE)
      SetPrinterReasons(job->printer, message);

    if (!strchr(job->status_buffer->buffer, '\n'))
      break;
  }

  if (ptr == NULL)
  {
   /*
    * See if all of the filters and the backend have returned their
    * exit statuses.
    */

    for (i = 0; job->filters[i] < 0; i ++);

    if (job->filters[i])
      return;

    if (job->current_file >= job->num_files && job->backend > 0)
      return;

   /*
    * Handle the end of job stuff...
    */

    FinishJob(job);
  }
}


/*
 * 'ipp_length()' - Compute the size of the buffer needed to hold 
 *                  the textual IPP attributes.
 */

int                                     /* O - Size of buffer to hold IPP attributes */
ipp_length(ipp_t *ipp)                  /* I - IPP request */
{
  int                   bytes;          /* Number of bytes */
  int                   i;              /* Looping var */
  ipp_attribute_t       *attr;          /* Current attribute */


 /*
  * Loop through all attributes...
  */

  bytes = 0;

  for (attr = ipp->attrs; attr != NULL; attr = attr->next)
  {
   /*
    * Skip attributes that won't be sent to filters...
    */

    if (attr->value_tag == IPP_TAG_MIMETYPE ||
        attr->value_tag == IPP_TAG_NAMELANG ||
        attr->value_tag == IPP_TAG_TEXTLANG ||
        attr->value_tag == IPP_TAG_URI ||
        attr->value_tag == IPP_TAG_URISCHEME)
      continue;

    if (strncmp(attr->name, "time-", 5) == 0)
      continue;

   /*
    * Add space for a leading space and commas between each value.
    * For the first attribute, the leading space isn't used, so the
    * extra byte can be used as the nul terminator...
    */

    bytes ++;                           /* " " separator */
    bytes += attr->num_values;          /* "," separators */

   /*
    * Boolean attributes appear as "foo,nofoo,foo,nofoo", while
    * other attributes appear as "foo=value1,value2,...,valueN".
    */

    if (attr->value_tag != IPP_TAG_BOOLEAN)
      bytes += strlen(attr->name);
    else
      bytes += attr->num_values * strlen(attr->name);

   /*
    * Now add the size required for each value in the attribute...
    */

    switch (attr->value_tag)
    {
      case IPP_TAG_INTEGER :
      case IPP_TAG_ENUM :
         /*
          * Minimum value of a signed integer is -2147483647, or 11 digits.
          */

          bytes += attr->num_values * 11;
          break;

      case IPP_TAG_BOOLEAN :
         /*
          * Add two bytes for each false ("no") value...
          */

          for (i = 0; i < attr->num_values; i ++)
            if (!attr->values[i].boolean)
              bytes += 2;
          break;

      case IPP_TAG_RANGE :
         /*
          * A range is two signed integers separated by a hyphen, or
          * 23 characters max.
          */

          bytes += attr->num_values * 23;
          break;

      case IPP_TAG_RESOLUTION :
         /*
          * A resolution is two signed integers separated by an "x" and
          * suffixed by the units, or 26 characters max.
          */

          bytes += attr->num_values * 26;
          break;

      case IPP_TAG_STRING :
      case IPP_TAG_TEXT :
      case IPP_TAG_NAME :
      case IPP_TAG_KEYWORD :
      case IPP_TAG_CHARSET :
      case IPP_TAG_LANGUAGE :
         /*
          * Strings can contain characters that need quoting.  We need
          * at least 2 * len + 2 characters to cover the quotes and
          * any backslashes in the string.
          */

          for (i = 0; i < attr->num_values; i ++)
            bytes += 2 * strlen(attr->values[i].string.text) + 2;
          break;

       default :
          break; /* anti-compiler-warning-code */
    }
  }

  return (bytes);
}


/*
 * 'set_time()' - Set one of the "time-at-xyz" attributes...
 */

static void
set_time(job_t      *job,       /* I - Job to update */
         const char *name)      /* I - Name of attribute */
{
  ipp_attribute_t       *attr;  /* Time attribute */


  if ((attr = ippFindAttribute(job->attrs, name, IPP_TAG_ZERO)) != NULL)
  {
    attr->value_tag         = IPP_TAG_INTEGER;
    attr->values[0].integer = time(NULL);
  }
}


/*
 * 'set_hold_until()' - Set the hold time and update job-hold-until attribute...
 */

static void 
set_hold_until(job_t *job,              /* I - Job to update */
               time_t holdtime)         /* I - Hold until time */
{
  ipp_attribute_t       *attr;          /* job-hold-until attribute */
  struct tm             *holddate;      /* Hold date */
  char                  holdstr[64];    /* Hold time */


 /*
  * Set the hold_until value and hold the job...
  */

  LogMessage(L_DEBUG, "set_hold_until: hold_until = %d", (int)holdtime);

  job->state->values[0].integer = IPP_JOB_HELD;
  job->hold_until               = holdtime;

 /*
  * Update the job-hold-until attribute with a string representing GMT
  * time (HH:MM:SS)...
  */

  holddate = gmtime(&holdtime);
  snprintf(holdstr, sizeof(holdstr), "%d:%d:%d", holddate->tm_hour, 
           holddate->tm_min, holddate->tm_sec);

  if ((attr = ippFindAttribute(job->attrs, "job-hold-until", IPP_TAG_KEYWORD)) == NULL)
    attr = ippFindAttribute(job->attrs, "job-hold-until", IPP_TAG_NAME);

 /*
  * Either add the attribute or update the value of the existing one
  */

  if (attr == NULL)
    attr = ippAddString(job->attrs, IPP_TAG_JOB, IPP_TAG_KEYWORD,
                        "job-hold-until", NULL, holdstr);
  else
    SetString(&attr->values[0].string.text, holdstr);

  SaveJob(job->id);
}


/*
 * End of "$Id$".
 */