Exemplo n.º 1
0
int decode_state(

  pbs_attribute *pattr,   /* I (modified) */
  char          *name,    /* pbs_attribute name */
  char          *rescn,   /* resource name, unused here */
  char          *val,     /* pbs_attribute value */
  int            perm)    /* only used for resources */

  {
  int   rc = 0;  /*return code; 0==success*/
  short flag, currflag;
  char  *str;

  char  strbuf[512]; /*should handle most vals*/
  char *sbufp;
  char *ptr = NULL;
  int   slen;

  if (val == NULL)
    {
    return(PBSE_BADNDATVAL);
    }

  /*
   * determine string storage requirement and copy the string "val"
   * to a work buffer area
  */

  slen = strlen(val); /*bufr either on stack or heap*/

  if (slen - 512 < 0)
    {
    sbufp = strbuf;
    }
  else
    {
    if (!(sbufp = (char *)calloc(1, slen + 1)))
      {
      return(PBSE_SYSTEM);
      }
    }

  strcpy(sbufp, val);

  if ((str = parse_comma_string(sbufp,&ptr)) == NULL)
    {
    if (slen >= 512)
      free(sbufp);

    return(rc);
    }

  flag = 0;

  if ((rc = set_nodeflag(str, &flag)) != 0)
    {
    if (slen >= 512)
      free(sbufp);

    return(rc);
    }

  currflag = flag;

  /*calling parse_comma_string with a null ptr continues where*/
  /*last call left off.  The initial comma separated string   */
  /*copy pointed to by sbufp is modified with each func call  */

  while ((str = parse_comma_string(NULL,&ptr)) != NULL)
    {
    if ((rc = set_nodeflag(str, &flag)) != 0)
      break;

    if (((currflag == 0) && flag) || (currflag && (flag == 0)))
      {
      rc = PBSE_MUTUALEX; /*free is mutually exclusive*/

      break;
      }

    currflag = flag;
    }

  if (!rc)
    {
    pattr->at_val.at_short = flag;
    pattr->at_flags |= ATR_VFLAG_SET | ATR_VFLAG_MODIFY;
    }

  if (slen >= 512) /* buffer on heap, not stack */
    free(sbufp);

  return(rc);
  }  /* END decode_state() */
Exemplo n.º 2
0
int
decode_state(attribute *pattr, char *name, char *rescn, char *val)
{
	int	rc = 0;		/*return code; 0==success*/
	unsigned long	flag, currflag;
	char	*str;

	char	strbuf[512];	/*should handle most vals*/
	char	*sbufp;
	int	slen;


	if (val == NULL)
		return (PBSE_BADNDATVAL);

	/*
	 * determine string storage requirement and copy the string "val"
	 * to a work buffer area
	 */

	slen = strlen(val);	/*bufr either on stack or heap*/
	if (slen - 512 < 0)
		sbufp = strbuf;
	else {
		if (!(sbufp = (char *)malloc(slen + 1)))
			return (PBSE_SYSTEM);
	}

	strcpy(sbufp, val);

	if ((str = parse_comma_string(sbufp)) == NULL) {
		if (slen >= 512)
			free(sbufp);
		return rc;
	}

	flag = 0;
	if ((rc = set_nodeflag(str, &flag)) != 0) {
		if (slen >= 512)
			free(sbufp);
		return rc;
	}
	currflag = flag;

	/*calling parse_comma_string with a null ptr continues where*/
	/*last call left off.  The initial comma separated string   */
	/*copy pointed to by sbufp is modified with each func call  */

	while ((str = parse_comma_string(NULL)) != 0) {
		if ((rc = set_nodeflag(str, &flag)) != 0)
			break;

		if ((currflag == 0 && flag) || (currflag && flag == 0)) {
			rc = PBSE_MUTUALEX;	/*free is mutually exclusive*/
			break;
		}
		currflag = flag;
	}

	if (!rc) {
		pattr->at_val.at_long = flag;
		pattr->at_flags |=
			ATR_VFLAG_SET|ATR_VFLAG_MODIFY|ATR_VFLAG_MODCACHE;
	}

	if (slen >= 512)		/*buffer on heap, not stack*/
		free(sbufp);

	return rc;
}