static const char *set_rule(cmd_parms *parms, void *mconfig, const char *arg)
{
    char *val;
    const char *err;
    rule_entry *rule;
    interval_limit_config *conf = mconfig;
    if (!conf){
        return "IntervalLimitModule: Failed to retrieve configuration for mod_interval_limit";
    }
    /* check if the number of rules exceeds MAX_RULE */
    if (conf->rules->nelts > MAX_RULE) {
        return apr_psprintf(parms->pool, "IntervalLimitModule: Cannot define more %d rules!", MAX_RULE);
    }

    rule = (rule_entry *)apr_array_push(conf->rules);
    val = (char*)apr_pstrdup(parms->pool, (char*)arg);

    /*  parse the rule argument line */
    if ( (err = parse_rule_line(parms->pool, val, rule) )!=NULL){
        return apr_psprintf(parms->pool, "IntervalLimitModule: %s", err);
    }
    /* check if there is no duplication among the names of rules */
    if (check_rule_name_duplication(rule->name, conf->rules)) {
        return apr_psprintf(parms->pool, "parse_rule_line: rule name duplication error: %s",rule->name);
    }
    return NULL;
}
Esempio n. 2
0
void
parse_olson_file                (char           *filename,
                                 GArray        **zone_data,
                                 GHashTable    **rule_data,
                                 GHashTable    **link_data,
                                 int            *max_until_year)
{
  ParsingData data;
  FILE *fp;
  int zone_continues = 0;

  *zone_data = g_array_new (FALSE, FALSE, sizeof (ZoneData));
  *rule_data = g_hash_table_new (g_str_hash, g_str_equal);
  *link_data = g_hash_table_new (g_str_hash, g_str_equal);

  fp = fopen (filename, "r");
  if (!fp) {
    fprintf (stderr, "Couldn't open file: %s\n", filename);
    exit (1);
  }

  data.filename = filename;
  data.zone_data = *zone_data;
  data.rule_data = *rule_data;
  data.link_data = *link_data;
  data.max_until_year = 0;

  for (data.line_number = 0; ; data.line_number++) {
    if (fgets (data.line, sizeof (data.line), fp) != data.line)
      break;

    strcpy (data.buffer, data.line);

    parse_fields (&data);
    if (data.num_fields == 0)
      continue;

    if (zone_continues) {
      zone_continues = parse_zone_continuation_line (&data);
    } else if (!strcmp (data.fields[0], "Zone")) {
      zone_continues = parse_zone_line (&data);
    } else if (!strcmp (data.fields[0], "Rule")) {
      parse_rule_line (&data);
    } else if (!strcmp (data.fields[0], "Link")) {
      parse_link_line (&data);
    } else if (!strcmp (data.fields[0], "Leap")) {
      /* We don't care about Leap lines. */
    } else {
      fprintf (stderr, "%s:%i: Invalid line.\n%s\n", filename,
               data.line_number, data.line);
      exit (1);
    }
  }

  if (ferror (fp)) {
    fprintf (stderr, "Error reading file: %s\n", filename);
    exit (1);
  }

  if (zone_continues) {
    fprintf (stderr, "%s:%i: Zone continuation line expected.\n%s\n",
             filename, data.line_number, data.line);
    exit (1);
  }

  fclose (fp);

#if 0
  printf ("Max UNTIL year: %i\n", data.max_until_year);
#endif
  *max_until_year = data.max_until_year;
}