validate.c

Solaris操作系统下的过滤驱动程序, C源码程序.

    return FALSE;
  }
  cp = (char *) &str[len-2];
  if (!STREQ(cp, ".c") && !STREQ(cp, ".h")) {
    sprintf(errmsg, "invalid C source/header file name: %s", str);
    return FALSE;
  }

  /* all is well */
  fist_globals.fg_usources[cur] = strdup(str);
  fist_globals.fg_num_usources++; /* increment */

  return TRUE;
}


/*
 * Validate added makefile, and perform necessary actions.
 * Return TRUE/FALSE.
 */
int
fist_validate_decl_addmk(const char *str, char *errmsg)
{
  struct stat statbuf;
  char buf[MAX_BUF_LEN];

  /* check if already defined one additional makefile */
  if (fist_globals.fg_addmk) {
    sprintf(errmsg, "must specify only one additional makefile");
    return FALSE;
  }

  sprintf(buf, "%s/%s", in_dir, str);
  if (lstat(buf, &statbuf) < 0) {
    sprintf(errmsg, "\"%s\": %s", str, strerror(errno));
    return FALSE;
  }

  /* all is well */
  fist_globals.fg_addmk = strdup(buf);
  return TRUE;
}


/*
 * Validate mntflags, and perform necessary actions.
 * Return TRUE/FALSE.
 */
int
fist_validate_decl_mntflag(const char *str, char *errmsg)
{
  int cur = fist_globals.fg_num_mntflags;
  int i;

  /* check if exceeded maximum number of mount flags */
  if (cur >= MAX_MNTFLAGS) {
    sprintf(errmsg, "too many mount flags (max=%d)", MAX_MNTFLAGS);
    return FALSE;
  }

  /* check if mount flag is already defined */
  if (cur > 0)
    for (i=0; i<cur; i++) {
      if (STREQ(str, fist_globals.fg_mntflags[i])) {
	strcpy(errmsg, "duplicate mount flag");
	return FALSE;
      }
    }

  /* all is well */
  fist_globals.fg_mntflags[cur] = strdup(str);
  fist_globals.fg_num_mntflags++; /* increment */
  //  fprintf(out_fp_h, "#define %s %d\n", str, cur+1);

  return TRUE;
}


/*
 * Validate file formats, and perform necessary actions.
 * Return TRUE/FALSE.
 */
int
fist_validate_decl_fileformat(const char *str, bdt_t *bdt, char *errmsg)
{
  int cur = fist_globals.fg_num_fileformats;
  int i;

  /* check if exceeded maximum number of file formats */
  if (cur >= MAX_FILE_FORMATS) {
    sprintf(errmsg, "too many file formats (max=%d)", MAX_FILE_FORMATS);
    return FALSE;
  }

  /* check if file format is already defined */
  if (cur > 0)
    for (i=0; i<cur; i++) {
      if (STREQ(str, fist_globals.fg_fileformat_name[i])) {
	strcpy(errmsg, "duplicate file format");
	return FALSE;
      }
    }

  /* all is well */
  fist_globals.fg_fileformat_name[cur] = strdup(str);
  fist_globals.fg_fileformat[cur] = bdt;
  fist_globals.fg_num_fileformats++; /* increment */

  return TRUE;
}


/*
 * check if an ioctl name exists
 * return TRUE if name exists, FALSE otherwise
 */
static int
fist_exist_ioctl_name(const char *str)
{
  int i;
  int cur = fist_globals.fg_num_ioctls;

  if (cur == 0)			/* no ioctls defined */
    return FALSE;

  for (i=0; i<cur; i++)
    if (STREQ(str, fist_globals.fg_ioctl_name[i]))
      return TRUE;

  return FALSE;
}


/*
 * Validate ioctls, and perform necessary actions.
 * Return TRUE/FALSE.
 */
int
fist_validate_decl_ioctl(const char *str, const char *type, bdt_t *bdt, char *errmsg)
{
  int cur = fist_globals.fg_num_ioctls;
  u_int iot;

  /* check if ioctl type is valid */
  if (STREQ(type, "both"))
    iot = FF_IOCTL_BOTH;
  else if (STREQ(type, "fromuser"))
    iot = FF_IOCTL_FROMUSER;
  else if (STREQ(type, "touser"))
    iot = FF_IOCTL_TOUSER;
  else if (STREQ(type, "none"))
    iot = FF_IOCTL_NONE;
  else {
    strcpy(errmsg, "unknown ioctl type");
    return FALSE;
  }

  /* check if exceeded maximum number of ioctls */
  if (cur >= MAX_IOCTLS) {
    sprintf(errmsg, "too many ioctls (max=%d)", MAX_IOCTLS);
    return FALSE;
  }

  /* check if ioctl is already defined */
  if (fist_exist_ioctl_name(str)) {
    strcpy(errmsg, "duplicate ioctl");
    return FALSE;
  }

  /* all is well */
  fist_globals.fg_ioctl_name[cur] = strdup(str);
  fist_globals.fg_ioctl[cur] = bdt;
  fist_globals.fg_ioctl_type[cur] = iot;
  fist_globals.fg_num_ioctls++; /* increment */

  return TRUE;
}


/*
 * Validate the 'callset' part of a fist rule definition.
 * Return TRUE/FALSE.
 */
static int
fist_validate_rule_callset(const char *str)
{
  char **tmp = valid_rule_callsets;

  if (!str || !str[0])
    return FALSE;

  while (*tmp) {
    if (STREQ(*tmp, str))
      return TRUE;
    tmp++;
  }
  return FALSE;
}


/*
 * Validate the 'optype' part of a fist rule definition.
 * Return TRUE/FALSE.
 */
static int
fist_validate_rule_optype(const char *str)
{
  char **tmp = valid_rule_optypes;

  if (!str || !str[0])
    return FALSE;

  while (*tmp) {
    if (STREQ(*tmp, str))
      return TRUE;
    tmp++;
  }
  return FALSE;
}


/*
 * Validate the 'part' part of a fist rule definition.
 * Return TRUE/FALSE.
 */
int
fist_validate_rule_part(const char *str)
{
  char **tmp = valid_rule_parts;

  if (!str || !str[0])
    return FALSE;

  while (*tmp) {
    if (STREQ(*tmp, str))
      return TRUE;
    tmp++;
  }
  return FALSE;
}


/*
 * Validate fist rule definition, and perform necessary actions.
 * Return TRUE/FALSE.
 */
int
fist_validate_rule_def(const char *str, char *errmsg, ecl_t **eclpp)
{
  int cur = fist_rules.fr_num_rules;
  int i;
  char buf[MAX_BUF_LEN], *callset, *optype, *part;

  /* check if exceeded maximum number of ioctls */
  if (cur >= MAX_RULES) {
    sprintf(errmsg, "too many rules (max=%d)", MAX_RULES);
    return FALSE;
  }

  /* simple check */
  if (!str || !str[0]) {
    sprintf(errmsg, "null/empty rule definition");
    return FALSE;
  }

  /* find components of rule definition, and validate them */
  strcpy(buf, str);
  callset = optype = part = NULL;
  callset = &buf[1];		/* skip '%' */
  optype = strchr(callset, ':');
  if (optype)
    *optype++ = '\0';
  if (optype) {
    part = strchr(optype, ':');
    if (part)
      *part++ = '\0';
  }
  if (!fist_validate_rule_callset(callset)) {
    sprintf(errmsg, "invalid callset \"%s\" in rule definition", callset);
    return FALSE;
  }
  if (!fist_validate_rule_optype(optype)) {
    sprintf(errmsg, "invalid optype in rule definition");
    return FALSE;
  }

  if (STREQ(optype, "ioctl")) {
    /* also check for newly defined ioctl names */
    if (!fist_validate_rule_part(part) && !fist_exist_ioctl_name(part)) {
      sprintf(errmsg, "invalid part/name in ioctl rule definition");
      return FALSE;
    }
  } else {
    if (!fist_validate_rule_part(part)) {
      sprintf(errmsg, "invalid part in rule definition");
      return FALSE;
    }
  }

  /* check if rule is already defined */
  if (cur > 0)
    for (i=0; i<cur; i++) {
      if (STREQ(callset, fist_rules.fr_callset[i]) &&
	  STREQ(optype, fist_rules.fr_optype[i]) &&
	  STREQ(part, fist_rules.fr_part[i])) {
	strcpy(errmsg, "duplicate rule definition");
	return FALSE;
      }
    }

  /* all is well */
  fist_rules.fr_callset[cur] = strdup(callset);
  fist_rules.fr_optype[cur] = strdup(optype);
  fist_rules.fr_part[cur] = strdup(part);

  /* create uppercase name of tag */
  sprintf(buf, "%s_%s_%s", callset, optype, part);
  uppercase_string(buf);
  fist_rules.fr_tag[cur] = strdup(buf);

  fist_rules.fr_code[cur] = (ecl_t *) calloc(1, sizeof(ecl_t));
  fist_rules.fr_code[cur]->buf = (*eclpp)->buf;
  (*eclpp)->buf = NULL;
  fist_rules.fr_code[cur]->len = (*eclpp)->len;
  fist_rules.fr_code[cur]->max = (*eclpp)->max;
  (*eclpp)->len = (*eclpp)->max = 0;

  fist_rules.fr_num_rules++;

  return TRUE;
}


/*
 * Validate fist rule tag syntax such as [FIST_]OP_LOOKUP_POSTCALL.
 * Return TRUE/FALSE.
 */
int
fist_validate_rule_tag(const char *str)
{
  char buf[MAX_BUF_LEN], *callset, *optype, *part;

  /* simple check */
  if (!str || !str[0])
    return FALSE;

  /* find components of rule definition, and validate them */
  strcpy(buf, str);
  lowercase_string(buf);
  callset = optype = part = NULL;
  callset = buf;
  optype = strchr(callset, '_');
  if (optype)
    *optype++ = '\0';
  if (optype) {
    part = strchr(optype, '_');
    if (part)
      *part++ = '\0';
  }
  if (!fist_validate_rule_callset(callset)) {
    return FALSE;
  }
  if (!fist_validate_rule_optype(optype)) {
    return FALSE;
  }
  if (!fist_validate_rule_part(part)) {
    return FALSE;
  }

  return TRUE;
}