/*

 * Option conflict management routines for CUPS.

 *

 * Copyright 2007-2018 by Apple Inc.

 * Copyright 1997-2007 by Easy Software Products, all rights reserved.

 *

 * These coded instructions, statements, and computer programs are the

 * property of Apple Inc. 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, see the license at "http://www.cups.org/".

 *

 * PostScript is a trademark of Adobe Systems, Inc.

 *

 * This file is subject to the Apple OS-Developed Software exception.

 */

/*

 * Include necessary headers...

 */

#include "cups-private.h"

#include "ppd-private.h"

/*

 * Local constants...

 */

enum

{

  _PPD_OPTION_CONSTRAINTS,

  _PPD_INSTALLABLE_CONSTRAINTS,

  _PPD_ALL_CONSTRAINTS

};

/*

 * Local functions...

 */

static int    ppd_is_installable(ppd_group_t *installable,

                         const char *option);

static void   ppd_load_constraints(ppd_file_t *ppd);

static cups_array_t *ppd_test_constraints(ppd_file_t *ppd,

                            const char *option,

                const char *choice,

                            int num_options,

                            cups_option_t *options,

                int which);

/*

 * 'cupsGetConflicts()' - Get a list of conflicting options in a marked PPD.

 *

 * This function gets a list of options that would conflict if "option" and

 * "choice" were marked in the PPD.  You would typically call this function

 * after marking the currently selected options in the PPD in order to

 * determine whether a new option selection would cause a conflict.

 *

 * The number of conflicting options are returned with "options" pointing to

 * the conflicting options.  The returned option array must be freed using

 * @link cupsFreeOptions@.

 *

 * @since CUPS 1.4/macOS 10.6@

 */

int         /* O - Number of conflicting options */

cupsGetConflicts(

    ppd_file_t    *ppd,     /* I - PPD file */

    const char    *option,    /* I - Option to test */

    const char    *choice,    /* I - Choice to test */

    cups_option_t **options)    /* O - Conflicting options */

{

  int     i,    /* Looping var */

      num_options;  /* Number of conflicting options */

  cups_array_t    *active;  /* Active conflicts */

  _ppd_cups_uiconsts_t  *c;   /* Current constraints */

  _ppd_cups_uiconst_t *cptr;    /* Current constraint */

  ppd_choice_t    *marked;  /* Marked choice */

 /*

  * Range check input...

  */

  if (options)

    *options = NULL;

  if (!ppd || !option || !choice || !options)

    return (0);

 /*

  * Test for conflicts...

  */

  active = ppd_test_constraints(ppd, option, choice, 0, NULL,

                                _PPD_ALL_CONSTRAINTS);

 /*

  * Loop through all of the UI constraints and add any options that conflict...

  */

  for (num_options = 0, c = (_ppd_cups_uiconsts_t *)cupsArrayFirst(active);

       c;

       c = (_ppd_cups_uiconsts_t *)cupsArrayNext(active))

  {

    for (i = c->num_constraints, cptr = c->constraints;

         i > 0;

   i --, cptr ++)

      if (_cups_strcasecmp(cptr->option->keyword, option))

      {

        if (cptr->choice)

    num_options = cupsAddOption(cptr->option->keyword,

                                cptr->choice->choice, num_options,

              options);

        else if ((marked = ppdFindMarkedChoice(ppd,

                                         cptr->option->keyword)) != NULL)

    num_options = cupsAddOption(cptr->option->keyword, marked->choice,

              num_options, options);

      }

  }

  cupsArrayDelete(active);

  return (num_options);

}

/*

 * 'cupsResolveConflicts()' - Resolve conflicts in a marked PPD.

 *

 * This function attempts to resolve any conflicts in a marked PPD, returning

 * a list of option changes that are required to resolve them.  On input,

 * "num_options" and "options" contain any pending option changes that have

 * not yet been marked, while "option" and "choice" contain the most recent

 * selection which may or may not be in "num_options" or "options".

 *

 * On successful return, "num_options" and "options" are updated to contain

 * "option" and "choice" along with any changes required to resolve conflicts

 * specified in the PPD file and 1 is returned.

 *

 * If option conflicts cannot be resolved, "num_options" and "options" are not

 * changed and 0 is returned.

 *

 * When resolving conflicts, @code cupsResolveConflicts@ does not consider

 * changes to the current page size (@code media@, @code PageSize@, and

 * @code PageRegion@) or to the most recent option specified in "option".

 * Thus, if the only way to resolve a conflict is to change the page size

 * or the option the user most recently changed, @code cupsResolveConflicts@

 * will return 0 to indicate it was unable to resolve the conflicts.

 *

 * The @code cupsResolveConflicts@ function uses one of two sources of option

 * constraint information.  The preferred constraint information is defined by

 * @code cupsUIConstraints@ and @code cupsUIResolver@ attributes - in this

 * case, the PPD file provides constraint resolution actions.

 *

 * The backup constraint information is defined by the

 * @code UIConstraints@ and @code NonUIConstraints@ attributes.  These

 * constraints are resolved algorithmically by first selecting the default

 * choice for the conflicting option, then iterating over all possible choices

 * until a non-conflicting option choice is found.

 *

 * @since CUPS 1.4/macOS 10.6@

 */

int         /* O  - 1 on success, 0 on failure */

cupsResolveConflicts(

    ppd_file_t    *ppd,     /* I  - PPD file */

    const char    *option,    /* I  - Newly selected option or @code NULL@ for none */

    const char    *choice,    /* I  - Newly selected choice or @code NULL@ for none */

    int           *num_options,   /* IO - Number of additional selected options */

    cups_option_t **options)    /* IO - Additional selected options */

{

  int     i,    /* Looping var */

      tries,    /* Number of tries */

      num_newopts;  /* Number of new options */

  cups_option_t   *newopts; /* New options */

  cups_array_t    *active = NULL, /* Active constraints */

      *pass,    /* Resolvers for this pass */

      *resolvers, /* Resolvers we have used */

      *test;    /* Test array for conflicts */

  _ppd_cups_uiconsts_t  *consts;  /* Current constraints */

  _ppd_cups_uiconst_t *constptr;  /* Current constraint */

  ppd_attr_t    *resolver;  /* Current resolver */

  const char    *resval;  /* Pointer into resolver value */

  char      resoption[PPD_MAX_NAME],

          /* Current resolver option */

      reschoice[PPD_MAX_NAME],

          /* Current resolver choice */

      *resptr,  /* Pointer into option/choice */

      firstpage[255]; /* AP_FIRSTPAGE_Keyword string */

  const char    *value;   /* Selected option value */

  int     changed;  /* Did we change anything? */

  ppd_choice_t    *marked;  /* Marked choice */

 /*

  * Range check input...

  */

  if (!ppd || !num_options || !options || (option == NULL) != (choice == NULL))

    return (0);

 /*

  * Build a shadow option array...

  */

  num_newopts = 0;

  newopts     = NULL;

  for (i = 0; i < *num_options; i ++)

    num_newopts = cupsAddOption((*options)[i].name, (*options)[i].value,

                                num_newopts, &newopts);

  if (option && _cups_strcasecmp(option, "Collate"))

    num_newopts = cupsAddOption(option, choice, num_newopts, &newopts);

 /*

  * Loop until we have no conflicts...

  */

  cupsArraySave(ppd->sorted_attrs);

  resolvers = NULL;

  pass      = cupsArrayNew((cups_array_func_t)_cups_strcasecmp, NULL);

  tries     = 0;

  while (tries < 100 &&

         (active = ppd_test_constraints(ppd, NULL, NULL, num_newopts, newopts,

                                        _PPD_ALL_CONSTRAINTS)) != NULL)

  {

    tries ++;

    if (!resolvers)

      resolvers = cupsArrayNew((cups_array_func_t)_cups_strcasecmp, NULL);

    for (consts = (_ppd_cups_uiconsts_t *)cupsArrayFirst(active), changed = 0;

         consts;

   consts = (_ppd_cups_uiconsts_t *)cupsArrayNext(active))

    {

      if (consts->resolver[0])

      {

       /*

        * Look up the resolver...

  */

        if (cupsArrayFind(pass, consts->resolver))

    continue;     /* Already applied this resolver... */

        if (cupsArrayFind(resolvers, consts->resolver))

  {

   /*

    * Resolver loop!

    */

    DEBUG_printf(("1cupsResolveConflicts: Resolver loop with %s!",

                  consts->resolver));

          goto error;

  }

        if ((resolver = ppdFindAttr(ppd, "cupsUIResolver",

                              consts->resolver)) == NULL)

        {

    DEBUG_printf(("1cupsResolveConflicts: Resolver %s not found!",

                  consts->resolver));

    goto error;

  }

        if (!resolver->value)

  {

    DEBUG_printf(("1cupsResolveConflicts: Resolver %s has no value!",

                  consts->resolver));

    goto error;

  }

       /*

        * Add the options from the resolver...

  */

        cupsArrayAdd(pass, consts->resolver);

  cupsArrayAdd(resolvers, consts->resolver);

        for (resval = resolver->value; *resval && !changed;)

  {

    while (_cups_isspace(*resval))

      resval ++;

    if (*resval != '*')

      break;

    for (resval ++, resptr = resoption;

         *resval && !_cups_isspace(*resval);

         resval ++)

            if (resptr < (resoption + sizeof(resoption) - 1))

        *resptr++ = *resval;

          *resptr = '\0';

    while (_cups_isspace(*resval))

      resval ++;

    for (resptr = reschoice;

         *resval && !_cups_isspace(*resval);

         resval ++)

            if (resptr < (reschoice + sizeof(reschoice) - 1))

        *resptr++ = *resval;

          *resptr = '\0';

          if (!resoption[0] || !reschoice[0])

      break;

         /*

    * Is this the option we are changing?

    */

          snprintf(firstpage, sizeof(firstpage), "AP_FIRSTPAGE_%s", resoption);

    if (option &&

        (!_cups_strcasecmp(resoption, option) ||

         !_cups_strcasecmp(firstpage, option) ||

         (!_cups_strcasecmp(option, "PageSize") &&

    !_cups_strcasecmp(resoption, "PageRegion")) ||

         (!_cups_strcasecmp(option, "AP_FIRSTPAGE_PageSize") &&

    !_cups_strcasecmp(resoption, "PageSize")) ||

         (!_cups_strcasecmp(option, "AP_FIRSTPAGE_PageSize") &&

    !_cups_strcasecmp(resoption, "PageRegion")) ||

         (!_cups_strcasecmp(option, "PageRegion") &&

          !_cups_strcasecmp(resoption, "PageSize")) ||

         (!_cups_strcasecmp(option, "AP_FIRSTPAGE_PageRegion") &&

          !_cups_strcasecmp(resoption, "PageSize")) ||

         (!_cups_strcasecmp(option, "AP_FIRSTPAGE_PageRegion") &&

          !_cups_strcasecmp(resoption, "PageRegion"))))

      continue;

   /*

    * Try this choice...

    */

          if ((test = ppd_test_constraints(ppd, resoption, reschoice,

             num_newopts, newopts,

             _PPD_ALL_CONSTRAINTS)) == NULL)

    {

     /*

      * That worked...

      */

            changed = 1;

    }

    else

            cupsArrayDelete(test);

   /*

    * Add the option/choice from the resolver regardless of whether it

    * worked; this makes sure that we can cascade several changes to

    * make things resolve...

    */

    num_newopts = cupsAddOption(resoption, reschoice, num_newopts,

              &newopts);

        }

      }

      else

      {

       /*

        * Try resolving by choosing the default values for non-installable

  * options, then by iterating through the possible choices...

  */

        int   j;    /* Looping var */

  ppd_choice_t  *cptr;    /* Current choice */

        ppd_size_t  *size;    /* Current page size */

        for (i = consts->num_constraints, constptr = consts->constraints;

       i > 0 && !changed;

       i --, constptr ++)

  {

   /*

    * Can't resolve by changing an installable option...

    */

    if (constptr->installable)

      continue;

         /*

    * Is this the option we are changing?

    */

    if (option &&

        (!_cups_strcasecmp(constptr->option->keyword, option) ||

         (!_cups_strcasecmp(option, "PageSize") &&

    !_cups_strcasecmp(constptr->option->keyword, "PageRegion")) ||

         (!_cups_strcasecmp(option, "PageRegion") &&

    !_cups_strcasecmp(constptr->option->keyword, "PageSize"))))

      continue;

         /*

    * Get the current option choice...

    */

          if ((value = cupsGetOption(constptr->option->keyword, num_newopts,

                               newopts)) == NULL)

          {

      if (!_cups_strcasecmp(constptr->option->keyword, "PageSize") ||

          !_cups_strcasecmp(constptr->option->keyword, "PageRegion"))

      {

        if ((value = cupsGetOption("PageSize", num_newopts,

                                   newopts)) == NULL)

                value = cupsGetOption("PageRegion", num_newopts, newopts);

              if (!value)

        {

          if ((size = ppdPageSize(ppd, NULL)) != NULL)

      value = size->name;

    else

      value = "";

        }

      }

      else

      {

        marked = ppdFindMarkedChoice(ppd, constptr->option->keyword);

        value  = marked ? marked->choice : "";

      }

    }

    if (!_cups_strncasecmp(value, "Custom.", 7))

      value = "Custom";

         /*

    * Try the default choice...

    */

          test = NULL;

          if (_cups_strcasecmp(value, constptr->option->defchoice) &&

        (test = ppd_test_constraints(ppd, constptr->option->keyword,

                                     constptr->option->defchoice,

             num_newopts, newopts,

             _PPD_OPTION_CONSTRAINTS)) == NULL)

    {

     /*

      * That worked...

      */

      num_newopts = cupsAddOption(constptr->option->keyword,

                                  constptr->option->defchoice,

          num_newopts, &newopts);

            changed     = 1;

    }

    else

    {

     /*

      * Try each choice instead...

      */

            for (j = constptr->option->num_choices,

               cptr = constptr->option->choices;

     j > 0;

     j --, cptr ++)

            {

        cupsArrayDelete(test);

        test = NULL;

        if (_cups_strcasecmp(value, cptr->choice) &&

            _cups_strcasecmp(constptr->option->defchoice, cptr->choice) &&

      _cups_strcasecmp("Custom", cptr->choice) &&

            (test = ppd_test_constraints(ppd, constptr->option->keyword,

                                         cptr->choice, num_newopts,

                 newopts,

                 _PPD_OPTION_CONSTRAINTS)) == NULL)

        {

         /*

    * This choice works...

    */

    num_newopts = cupsAddOption(constptr->option->keyword,

              cptr->choice, num_newopts,

              &newopts);

    changed     = 1;

    break;

        }

      }

      cupsArrayDelete(test);

          }

        }

      }

    }

    if (!changed)

    {

      DEBUG_puts("1cupsResolveConflicts: Unable to automatically resolve "

     "constraint!");

      goto error;

    }

    cupsArrayClear(pass);

    cupsArrayDelete(active);

    active = NULL;

  }

  if (tries >= 100)

    goto error;

 /*

  * Free the caller's option array...

  */

  cupsFreeOptions(*num_options, *options);

 /*

  * If Collate is the option we are testing, add it here.  Otherwise, remove

  * any Collate option from the resolve list since the filters automatically

  * handle manual collation...

  */

  if (option && !_cups_strcasecmp(option, "Collate"))

    num_newopts = cupsAddOption(option, choice, num_newopts, &newopts);

  else

    num_newopts = cupsRemoveOption("Collate", num_newopts, &newopts);

 /*

  * Return the new list of options to the caller...

  */

  *num_options = num_newopts;

  *options     = newopts;

  cupsArrayDelete(pass);

  cupsArrayDelete(resolvers);

  cupsArrayRestore(ppd->sorted_attrs);

  DEBUG_printf(("1cupsResolveConflicts: Returning %d options:", num_newopts));

#ifdef DEBUG

  for (i = 0; i < num_newopts; i ++)

    DEBUG_printf(("1cupsResolveConflicts: options[%d]: %s=%s", i,

                  newopts[i].name, newopts[i].value));

#endif /* DEBUG */

  return (1);

 /*

  * If we get here, we failed to resolve...

  */

  error:

  cupsFreeOptions(num_newopts, newopts);

  cupsArrayDelete(active);

  cupsArrayDelete(pass);

  cupsArrayDelete(resolvers);

  cupsArrayRestore(ppd->sorted_attrs);

  DEBUG_puts("1cupsResolveConflicts: Unable to resolve conflicts!");

  return (0);

}

/*

 * 'ppdConflicts()' - Check to see if there are any conflicts among the

 *                    marked option choices.

 *

 * The returned value is the same as returned by @link ppdMarkOption@.

 */

int         /* O - Number of conflicts found */

ppdConflicts(ppd_file_t *ppd)   /* I - PPD to check */

{

  int     i,    /* Looping variable */

      conflicts;  /* Number of conflicts */

  cups_array_t    *active;  /* Active conflicts */

  _ppd_cups_uiconsts_t  *c;   /* Current constraints */

  _ppd_cups_uiconst_t *cptr;    /* Current constraint */

  ppd_option_t  *o;     /* Current option */

  if (!ppd)

    return (0);

 /*

  * Clear all conflicts...

  */

  cupsArraySave(ppd->options);

  for (o = ppdFirstOption(ppd); o; o = ppdNextOption(ppd))

    o->conflicted = 0;

  cupsArrayRestore(ppd->options);

 /*

  * Test for conflicts...

  */

  active    = ppd_test_constraints(ppd, NULL, NULL, 0, NULL,

                                   _PPD_ALL_CONSTRAINTS);

  conflicts = cupsArrayCount(active);

 /*

  * Loop through all of the UI constraints and flag any options

  * that conflict...

  */

  for (c = (_ppd_cups_uiconsts_t *)cupsArrayFirst(active);

       c;

       c = (_ppd_cups_uiconsts_t *)cupsArrayNext(active))

  {

    for (i = c->num_constraints, cptr = c->constraints;

         i > 0;

   i --, cptr ++)

      cptr->option->conflicted = 1;

  }

  cupsArrayDelete(active);

 /*

  * Return the number of conflicts found...

  */

  return (conflicts);

}

/*

 * 'ppdInstallableConflict()' - Test whether an option choice conflicts with

 *                              an installable option.

 *

 * This function tests whether a particular option choice is available based

 * on constraints against options in the "InstallableOptions" group.

 *

 * @since CUPS 1.4/macOS 10.6@

 */

int         /* O - 1 if conflicting, 0 if not conflicting */

ppdInstallableConflict(

    ppd_file_t *ppd,      /* I - PPD file */

    const char *option,     /* I - Option */

    const char *choice)     /* I - Choice */

{

  cups_array_t  *active;    /* Active conflicts */

  DEBUG_printf(("2ppdInstallableConflict(ppd=%p, option=\"%s\", choice=\"%s\")",

                ppd, option, choice));

 /*

  * Range check input...

  */

  if (!ppd || !option || !choice)

    return (0);

 /*

  * Test constraints using the new option...

  */

  active = ppd_test_constraints(ppd, option, choice, 0, NULL,

        _PPD_INSTALLABLE_CONSTRAINTS);

  cupsArrayDelete(active);

  return (active != NULL);

}

/*

 * 'ppd_is_installable()' - Determine whether an option is in the

 *                          InstallableOptions group.

 */

static int        /* O - 1 if installable, 0 if normal */

ppd_is_installable(

    ppd_group_t *installable,   /* I - InstallableOptions group */

    const char  *name)      /* I - Option name */

{

  if (installable)

  {

    int     i;    /* Looping var */

    ppd_option_t  *option;  /* Current option */

    for (i = installable->num_options, option = installable->options;

         i > 0;

   i --, option ++)

      if (!_cups_strcasecmp(option->keyword, name))

        return (1);

  }

  return (0);

}

/*

 * 'ppd_load_constraints()' - Load constraints from a PPD file.

 */

static void

ppd_load_constraints(ppd_file_t *ppd) /* I - PPD file */

{

  int   i;      /* Looping var */

  ppd_const_t *oldconst;    /* Current UIConstraints data */

  ppd_attr_t  *constattr;   /* Current cupsUIConstraints attribute */

  _ppd_cups_uiconsts_t  *consts;  /* Current cupsUIConstraints data */

  _ppd_cups_uiconst_t *constptr;  /* Current constraint */

  ppd_group_t *installable;   /* Installable options group */

  const char  *vptr;      /* Pointer into constraint value */

  char    option[PPD_MAX_NAME], /* Option name/MainKeyword */

    choice[PPD_MAX_NAME], /* Choice/OptionKeyword */

    *ptr;     /* Pointer into option or choice */

  DEBUG_printf(("7ppd_load_constraints(ppd=%p)", ppd));

 /*

  * Create an array to hold the constraint data...

  */

  ppd->cups_uiconstraints = cupsArrayNew(NULL, NULL);

 /*

  * Find the installable options group if it exists...

  */

  for (i = ppd->num_groups, installable = ppd->groups;

       i > 0;

       i --, installable ++)

    if (!_cups_strcasecmp(installable->name, "InstallableOptions"))

      break;

  if (i <= 0)

    installable = NULL;

 /*

  * Load old-style [Non]UIConstraints data...

  */

  for (i = ppd->num_consts, oldconst = ppd->consts; i > 0; i --, oldconst ++)

  {

   /*

    * Weed out nearby duplicates, since the PPD spec requires that you

    * define both "*Foo foo *Bar bar" and "*Bar bar *Foo foo"...

    */

    if (i > 1 &&

  !_cups_strcasecmp(oldconst[0].option1, oldconst[1].option2) &&

  !_cups_strcasecmp(oldconst[0].choice1, oldconst[1].choice2) &&

  !_cups_strcasecmp(oldconst[0].option2, oldconst[1].option1) &&

  !_cups_strcasecmp(oldconst[0].choice2, oldconst[1].choice1))

      continue;

   /*

    * Allocate memory...

    */

    if ((consts = calloc(1, sizeof(_ppd_cups_uiconsts_t))) == NULL)

    {

      DEBUG_puts("8ppd_load_constraints: Unable to allocate memory for "

     "UIConstraints!");

      return;

    }

    if ((constptr = calloc(2, sizeof(_ppd_cups_uiconst_t))) == NULL)

    {

      free(consts);

      DEBUG_puts("8ppd_load_constraints: Unable to allocate memory for "

     "UIConstraints!");

      return;

    }

   /*

    * Fill in the information...

    */

    consts->num_constraints = 2;

    consts->constraints     = constptr;

    if (!_cups_strncasecmp(oldconst->option1, "Custom", 6) &&

  !_cups_strcasecmp(oldconst->choice1, "True"))

    {

      constptr[0].option      = ppdFindOption(ppd, oldconst->option1 + 6);

      constptr[0].choice      = ppdFindChoice(constptr[0].option, "Custom");

      constptr[0].installable = 0;

    }

    else

    {

      constptr[0].option      = ppdFindOption(ppd, oldconst->option1);

      constptr[0].choice      = ppdFindChoice(constptr[0].option,

                oldconst->choice1);

      constptr[0].installable = ppd_is_installable(installable,

               oldconst->option1);

    }

    if (!constptr[0].option || (!constptr[0].choice && oldconst->choice1[0]))

    {

      DEBUG_printf(("8ppd_load_constraints: Unknown option *%s %s!",

        oldconst->option1, oldconst->choice1));

      free(consts->constraints);

      free(consts);

      continue;

    }

    if (!_cups_strncasecmp(oldconst->option2, "Custom", 6) &&

  !_cups_strcasecmp(oldconst->choice2, "True"))

    {

      constptr[1].option      = ppdFindOption(ppd, oldconst->option2 + 6);

      constptr[1].choice      = ppdFindChoice(constptr[1].option, "Custom");

      constptr[1].installable = 0;

    }

    else

    {

      constptr[1].option      = ppdFindOption(ppd, oldconst->option2);

      constptr[1].choice      = ppdFindChoice(constptr[1].option,

                oldconst->choice2);

      constptr[1].installable = ppd_is_installable(installable,

               oldconst->option2);

    }

    if (!constptr[1].option || (!constptr[1].choice && oldconst->choice2[0]))

    {

      DEBUG_printf(("8ppd_load_constraints: Unknown option *%s %s!",

        oldconst->option2, oldconst->choice2));

      free(consts->constraints);

      free(consts);

      continue;

    }

    consts->installable = constptr[0].installable || constptr[1].installable;

   /*

    * Add it to the constraints array...

    */

    cupsArrayAdd(ppd->cups_uiconstraints, consts);

  }

 /*

  * Then load new-style constraints...

  */

  for (constattr = ppdFindAttr(ppd, "cupsUIConstraints", NULL);

       constattr;

       constattr = ppdFindNextAttr(ppd, "cupsUIConstraints", NULL))

  {

    if (!constattr->value)

    {

      DEBUG_puts("8ppd_load_constraints: Bad cupsUIConstraints value!");

      continue;

    }

    for (i = 0, vptr = strchr(constattr->value, '*');

   vptr;

   i ++, vptr = strchr(vptr + 1, '*'));

    if (i == 0)

    {

      DEBUG_puts("8ppd_load_constraints: Bad cupsUIConstraints value!");

      continue;

    }

    if ((consts = calloc(1, sizeof(_ppd_cups_uiconsts_t))) == NULL)

    {

      DEBUG_puts("8ppd_load_constraints: Unable to allocate memory for "

     "cupsUIConstraints!");

      return;

    }

    if ((constptr = calloc((size_t)i, sizeof(_ppd_cups_uiconst_t))) == NULL)

    {

      free(consts);

      DEBUG_puts("8ppd_load_constraints: Unable to allocate memory for "

     "cupsUIConstraints!");

      return;

    }

    consts->num_constraints = i;

    consts->constraints     = constptr;

    strlcpy(consts->resolver, constattr->spec, sizeof(consts->resolver));

    for (i = 0, vptr = strchr(constattr->value, '*');

   vptr;

   i ++, vptr = strchr(vptr, '*'), constptr ++)

    {

     /*

      * Extract "*Option Choice" or just "*Option"...

      */

      for (vptr ++, ptr = option; *vptr && !_cups_isspace(*vptr); vptr ++)

  if (ptr < (option + sizeof(option) - 1))

    *ptr++ = *vptr;

      *ptr = '\0';

      while (_cups_isspace(*vptr))

  vptr ++;

      if (*vptr == '*')

  choice[0] = '\0';

      else

      {

  for (ptr = choice; *vptr && !_cups_isspace(*vptr); vptr ++)

    if (ptr < (choice + sizeof(choice) - 1))

      *ptr++ = *vptr;

  *ptr = '\0';

      }

      if (!_cups_strncasecmp(option, "Custom", 6) && !_cups_strcasecmp(choice, "True"))

      {

  _cups_strcpy(option, option + 6);

  strlcpy(choice, "Custom", sizeof(choice));

      }

      constptr->option      = ppdFindOption(ppd, option);

      constptr->choice      = ppdFindChoice(constptr->option, choice);

      constptr->installable = ppd_is_installable(installable, option);

      consts->installable   |= constptr->installable;