Attachment #102 for bug #168

View | Details | Raw Unified
Collapse All | Expand All




#define MAX_PROCS_DIGITS  15 /* A 15 digit number is a lot of processors. 100 trillion 
                                     will this be enough for the future? */


/* Session descriptor for get_name_value() */
struct parse_name_value {
  char *name;			/* Last name that was processed */
  char *buffer;			/* Buffer with input string */
  char *curpos;			/* Current position inside buffer */
  unsigned char flags;		/* Flags for the session */
};
#define PNV_BADSYNTAX		0x01


static char PBS_DPREFIX_DEFAULT[] = "#PBS";

char PBS_Filter[256];




/*
 * Strips trailing blank characters.
 */
static void chomp_blanks(s)
char *s;



  {
  size_t len;


  for (len = strlen(s) - 1; len >= 0 && isspace(s[len]); len--);
  s[len + 1] = '\0';
  }  /* END chomp_blanks() */

  int sq_count = 0;
  int dq_count = 0;
  int sb_count = 0;

  char *tmpLine = NULL;
  int   tmpLineSize;
  int   tindex;

/*
 * Parses argument lists like 'name=value[,value,value],name=value'.
 * The first form, with many values for a single name will be
 * permitted only if 'name' is found in the array multiarg_OK.
 *
 * When 'start' is non-NULL this means that a new parsing session
 * with the buffer 'start' is pointing to will be created.
 *
 * Any subsequent calls to this function with 'start' being NULL
 * means "continue the parsing from the last position".
 *
 * Return values:
 * 1: new name/value pair was parsed;
 * 0: end of string reached, nothing new was parsed;
 * -1: memory allocation error (won't happen when start == NULL);
 * -2: bad line contents.
 */
int get_name_value(session, start, name, value, multiarg_OK)
struct parse_name_value *session;
char  *start;
char **name;
char **value;
const char *multiarg_OK[];
  {
  char *p;

  assert(session != NULL);
  assert(name != NULL);
  assert(value != NULL);

  if (start != NULL)


    {
    size_t len = strlen(start);

    bzero((void *)session, sizeof(*session));
    session->buffer = (char *)malloc(len + 1);
    if (session->buffer == NULL)
      return (-1);
    strncpy(session->buffer, start, len);
    session->buffer[len] = '\0';
    session->curpos = session->buffer;
    }
  else
    {
    assert(session->buffer != NULL);
    assert(session->curpos >= session->curpos);
    if (session->flags & PNV_BADSYNTAX)
      return (-2);
    }

  if (session->curpos[0] == '\0')
    return (0);









  while (isspace(session->curpos[0]))
    session->curpos++;

  /* Look for the name */
  for (p = session->curpos; *p != '='; p++)
    {
    if (*p == '\0' || *p == ',')
      {
      unsigned char permit_multi = 0;
      size_t i;

      if (session->name != NULL)
        {
        /*
         * Reuse the last seen name (for second and successive 'value'
         * in 'name=value[,value,value,...]') if it is permitted
         * by multiarg_OK.
         */
        for (i = 0; multiarg_OK[i] != NULL; i++)
          if (strcmp(session->name, multiarg_OK[i]) == 0)






            {
            permit_multi = 1;
            break;








            }
          }

        if (ignore == TRUE)
          {
          ptr++;

          ignchar = TRUE;
          }
        }
      }
    else if (*ptr == '\"')
      {
      dq_count++;

      if (permit_multi)
        {
        *name = session->name;
        *value = session->curpos;
        if (*p != '\0')






          {
          *p = '\0';
          session->curpos = p + 1;













          }
        else
          session->curpos = p;

        goto _try_to_return_result;





        }
      }
    else if (*ptr == '[' )
      {
      sb_count = 1;
      }
    else if (*ptr == ']')
      {
      sb_count = 0;
      }
    else if (*ptr == '{')
      {
      sb_count = 1;
      }
    else if (*ptr == '}')
      {
      sb_count = 0;
      }
    else if (!(sq_count % 2) && !(dq_count % 2) && (sb_count == 0))
      {
      /* not in quotations, locate delimiter */

      for (dindex = 0; delims[dindex] != '\0'; dindex++)
        {
        if (*ptr != delims[dindex])
          continue;

      session->flags |= PNV_BADSYNTAX;
      return (-2);
















































      }
    }

  /* Cache current name and skip blanks */
  *p = '\0';
  session->name = session->curpos;
  p++;
  while (isspace(*p))
    p++;
  session->curpos = p;











  /* Look for the value */
  for (; *p != '\0' && *p != ','; p++);

  *name = session->name;
  *value = session->curpos;
  if (*p != '\0')
















    {
    *p = '\0';
    session->curpos = p + 1;

    }
  else
    session->curpos = p;

_try_to_return_result:
  /*
   * Almost done, need to strip trailing blanks
   * and check empty name/value.
   */
  chomp_blanks(*name);
  chomp_blanks(*value);
  if (**name == '\0' || **value == '\0')
    {
    session->flags |= PNV_BADSYNTAX;
    return (-2);
    }

  return (1);
  }  /* END get_name_value() */























  if (*equals == '\0')
    return(-1);

/*
 * Frees memory associated with name/value parsing session.
 */
void free_name_value_session(session)
struct parse_name_value *session;
  {
  assert(session != NULL);

  if (session->buffer != NULL)
    free((void *)session->buffer);
  bzero((void *)session, sizeof(*session));
  }  /* END free_name_value_session */




  int nitems;
  char search_string[256];

  struct parse_name_value gnv_session;

  /*
   * Array of directives for -W for which we permit
   * multivalued specifications like name=value1,value2,value3.
   * Must be NULL-terminated.
   */
  static const char *optW_multiarg[] = {
    "stagein", "stageout",
    NULL
  };

#if !defined(PBS_NO_POSIX_VIOLATION)
#define GETOPT_ARGS "a:A:b:c:C:d:D:e:fF:hIJ:j:k:l:m:M:N:o:p:P:q:r:S:t:T:u:v:Vw:W:Xxz-:"
#else

          break;
          }

        i = get_name_value(&gnv_session, optarg,
          &keyword, &valuewd, optW_multiarg);

        if (i != 1)
          {

          snprintf(tmpLine, sizeof(tmpLine), "x=%s",
                   optarg);

          i = get_name_value(&gnv_session, tmpLine,
            &keyword, &valuewd, optW_multiarg);
          }

        while (i == 1)

            set_attr(&attrib, keyword, valuewd);
            }

          i = get_name_value(&gnv_session, NULL,
            &keyword, &valuewd, optW_multiarg);
          }  /* END while (i == 1) */

        if (i == -2)
          {
          fprintf(stderr, "qsub: illegal -W value '%s' "
            "for keyword '%s'\n", valuewd, keyword);

          errflg++;
          }

        if (i == -1)
          {
          fprintf(stderr, "qsub: not enough memory to parse -W value\n");

          errflg++;
          }

        break;

#if !defined(PBS_NO_POSIX_VIOLATION)