unsigned long prev_type;
int cur_type;
int nbargs;
+ int operator = STD_OP_EQ;
+ int op;
+ int contain_colon, have_dot;
+ const char *dot;
+ signed long long value, minor;
+ /* The following buffer contain two numbers, a ':' separator and the final \0. */
+ char buffer[NB_LLMAX_STR + 1 + NB_LLMAX_STR + 1];
+ const char *text[2];
/* First, we look for an ACL keyword. And if we don't find one, then
* we look for a sample fetch expression starting with a sample fetch
/* now parse all patterns */
pattern = NULL;
- if (!pattern_register(&expr->pat, args, NULL, &pattern, patflags, err))
- goto out_free_pattern;
+ while (**args) {
+ arg = *args;
+
+ /* Compatibility layer. Each pattern can parse only one string per pattern,
+ * but the pat_parser_int() and pat_parse_dotted_ver() parsers were need
+ * optionnaly two operators. The first operator is the match method: eq,
+ * le, lt, ge and gt. pat_parse_int() and pat_parse_dotted_ver() functions
+ * can have a compatibility syntax based on ranges:
+ *
+ * pat_parse_int():
+ *
+ * "eq x" -> "x" or "x:x"
+ * "le x" -> ":x"
+ * "lt x" -> ":y" (with y = x - 1)
+ * "ge x" -> "x:"
+ * "gt x" -> "y:" (with y = x + 1)
+ *
+ * pat_parse_dotted_ver():
+ *
+ * "eq x.y" -> "x.y" or "x.y:x.y"
+ * "le x.y" -> ":x.y"
+ * "lt x.y" -> ":w.z" (with w.z = x.y - 1)
+ * "ge x.y" -> "x.y:"
+ * "gt x.y" -> "w.z:" (with w.z = x.y + 1)
+ *
+ * If y is not present, assume that is "0".
+ *
+ * The syntax eq, le, lt, ge and gt are proper to the acl syntax. The
+ * following block of code detect the operator, and rewrite each value
+ * in parsable string.
+ */
+ if (expr->pat.parse == pat_parse_int ||
+ expr->pat.parse == pat_parse_dotted_ver) {
+ /* Check for operator. If the argument is operator, memorise it and
+ * continue to the next argument.
+ */
+ op = get_std_op(arg);
+ if (op != -1) {
+ operator = op;
+ args++;
+ continue;
+ }
+
+ /* Check if the pattern contain ':' or '-' character. */
+ contain_colon = (strchr(arg, ':') || strchr(arg, '-'));
+
+ /* If the pattern contain ':' or '-' character, give it to the parser as is.
+ * If no contain ':' and operator is STD_OP_EQ, give it to the parser as is.
+ * In other case, try to convert the value according with the operator.
+ */
+ if (!contain_colon && operator != STD_OP_EQ) {
+ /* Search '.' separator. */
+ dot = strchr(arg, '.');
+ if (!dot) {
+ have_dot = 0;
+ minor = 0;
+ dot = arg + strlen(arg);
+ }
+ else
+ have_dot = 1;
+
+ /* convert the integer minor part for the pat_parse_dotted_ver() function. */
+ if (expr->pat.parse == pat_parse_dotted_ver && have_dot) {
+ if (strl2llrc(dot+1, strlen(dot+1), &minor) != 0) {
+ memprintf(err, "'%s' is neither a number nor a supported operator", arg);
+ goto out_free_pattern;
+ }
+ if (minor >= 65536) {
+ memprintf(err, "'%s' contains too large a minor value", arg);
+ goto out_free_pattern;
+ }
+ }
+
+ /* convert the integer value for the pat_parse_int() function, and the
+ * integer major part for the pat_parse_dotted_ver() function.
+ */
+ if (strl2llrc(arg, dot - arg, &value) != 0) {
+ memprintf(err, "'%s' is neither a number nor a supported operator", arg);
+ goto out_free_pattern;
+ }
+ if (expr->pat.parse == pat_parse_dotted_ver) {
+ if (value >= 65536) {
+ memprintf(err, "'%s' contains too large a major value", arg);
+ goto out_free_pattern;
+ }
+ value = (value << 16) | (minor & 0xffff);
+ }
+
+ switch (operator) {
+
+ case STD_OP_EQ: /* this case is not possible. */
+ memprintf(err, "internal error");
+ goto out_free_pattern;
+
+ case STD_OP_GT:
+ value++; /* gt = ge + 1 */
+
+ case STD_OP_GE:
+ if (expr->pat.parse == pat_parse_int)
+ snprintf(buffer, NB_LLMAX_STR+NB_LLMAX_STR+2, "%lld:", value);
+ else
+ snprintf(buffer, NB_LLMAX_STR+NB_LLMAX_STR+2, "%lld.%lld:",
+ value >> 16, value & 0xffff);
+ arg = buffer;
+ break;
+
+ case STD_OP_LT:
+ value--; /* lt = le - 1 */
+
+ case STD_OP_LE:
+ if (expr->pat.parse == pat_parse_int)
+ snprintf(buffer, NB_LLMAX_STR+NB_LLMAX_STR+2, ":%lld", value);
+ else
+ snprintf(buffer, NB_LLMAX_STR+NB_LLMAX_STR+2, ":%lld.%lld",
+ value >> 16, value & 0xffff);
+ arg = buffer;
+ break;
+ }
+ }
+ }
+
+ text[0] = arg;
+ text[1] = "";
+ if (!pattern_register(&expr->pat, text, NULL, &pattern, patflags, err))
+ goto out_free_pattern;
+ args++;
+ }
return expr;
* The operator is stored in the 'opaque' argument.
*
* If err is non-NULL, an error message will be returned there on errors and
- * the caller will have to free it.
+ * the caller will have to free it. The function returns zero on error, and
+ * non-zero on success.
*
*/
int pat_parse_int(const char **text, struct pattern *pattern, enum pat_usage usage, int *opaque, char **err)
{
- signed long long i;
- unsigned int j, last, skip = 0;
const char *ptr = *text;
pattern->type = SMP_T_UINT;
pattern->expect_type = SMP_T_UINT;
- while (!isdigit((unsigned char)*ptr)) {
- switch (get_std_op(ptr)) {
- case STD_OP_EQ: *opaque = 0; break;
- case STD_OP_GT: *opaque = 1; break;
- case STD_OP_GE: *opaque = 2; break;
- case STD_OP_LT: *opaque = 3; break;
- case STD_OP_LE: *opaque = 4; break;
- default:
- memprintf(err, "'%s' is neither a number nor a supported operator", ptr);
- return 0;
- }
+ /* Empty string is not valid */
+ if (!**text)
+ goto not_valid_range;
- skip++;
- ptr = text[skip];
- }
+ /* Search ':' or '-' separator. */
+ while (*ptr != '\0' && *ptr != ':' && *ptr != '-')
+ ptr++;
- last = i = 0;
- while (1) {
- j = *ptr++;
- if ((j == '-' || j == ':') && !last) {
- last++;
- pattern->val.range.min = i;
- i = 0;
- continue;
+ /* If separator not found. */
+ if (!*ptr) {
+ if (strl2llrc(*text, ptr - *text, &pattern->val.range.min) != 0) {
+ memprintf(err, "'%s' is not a number", *text);
+ return 0;
}
- j -= '0';
- if (j > 9)
- // also catches the terminating zero
- break;
- i *= 10;
- i += j;
- }
-
- if (last && *opaque >= 1 && *opaque <= 4) {
- /* having a range with a min or a max is absurd */
- memprintf(err, "integer range '%s' specified with a comparison operator", text[skip]);
- return 0;
+ pattern->val.range.max = pattern->val.range.min;
+ pattern->val.range.min_set = 1;
+ pattern->val.range.max_set = 1;
+ return 1;
}
- if (!last)
- pattern->val.range.min = i;
- pattern->val.range.max = i;
+ /* If the separator is the first character. */
+ if (ptr == *text && *(ptr + 1) != '\0') {
+ if (strl2llrc(ptr + 1, strlen(ptr + 1), &pattern->val.range.max) != 0)
+ goto not_valid_range;
- switch (*opaque) {
- case 0: /* eq */
- pattern->val.range.min_set = 1;
+ pattern->val.range.min_set = 0;
pattern->val.range.max_set = 1;
- break;
- case 1: /* gt */
- pattern->val.range.min++; /* gt = ge + 1 */
- case 2: /* ge */
+ return 1;
+ }
+
+ /* If separator is the last character. */
+ if (*(ptr + 1) == '\0') {
+ if (strl2llrc(*text, ptr - *text, &pattern->val.range.min) != 0)
+ goto not_valid_range;
+
pattern->val.range.min_set = 1;
pattern->val.range.max_set = 0;
- break;
- case 3: /* lt */
- pattern->val.range.max--; /* lt = le - 1 */
- case 4: /* le */
- pattern->val.range.min_set = 0;
- pattern->val.range.max_set = 1;
- break;
+ return 1;
}
- return skip + 1;
+
+ /* Else, parse two numbers. */
+ if (strl2llrc(*text, ptr - *text, &pattern->val.range.min) != 0)
+ goto not_valid_range;
+
+ if (strl2llrc(ptr + 1, strlen(ptr + 1), &pattern->val.range.max) != 0)
+ goto not_valid_range;
+
+ if (pattern->val.range.min > pattern->val.range.max)
+ goto not_valid_range;
+
+ pattern->val.range.min_set = 1;
+ pattern->val.range.max_set = 1;
+ return 1;
+
+ not_valid_range:
+ memprintf(err, "'%s' is not a valid number range", *text);
+ return 0;
}
int pat_parse_len(const char **text, struct pattern *pattern, enum pat_usage usage, int *opaque, char **err)
*/
int pat_parse_dotted_ver(const char **text, struct pattern *pattern, enum pat_usage usage, int *opaque, char **err)
{
- signed long long i;
- unsigned int j, last, skip = 0;
const char *ptr = *text;
+ pattern->type = SMP_T_UINT;
+ pattern->expect_type = SMP_T_UINT;
- while (!isdigit((unsigned char)*ptr)) {
- switch (get_std_op(ptr)) {
- case STD_OP_EQ: *opaque = 0; break;
- case STD_OP_GT: *opaque = 1; break;
- case STD_OP_GE: *opaque = 2; break;
- case STD_OP_LT: *opaque = 3; break;
- case STD_OP_LE: *opaque = 4; break;
- default:
- memprintf(err, "'%s' is neither a number nor a supported operator", ptr);
+ /* Search ':' or '-' separator. */
+ while (*ptr != '\0' && *ptr != ':' && *ptr != '-')
+ ptr++;
+
+ /* If separator not found. */
+ if (*ptr == '\0' && ptr > *text) {
+ if (strl2llrc_dotted(*text, ptr-*text, &pattern->val.range.min) != 0) {
+ memprintf(err, "'%s' is not a dotted number", *text);
return 0;
}
-
- skip++;
- ptr = text[skip];
+ pattern->val.range.max = pattern->val.range.min;
+ pattern->val.range.min_set = 1;
+ pattern->val.range.max_set = 1;
+ return 1;
}
- last = i = 0;
- while (1) {
- j = *ptr++;
- if (j == '.') {
- /* minor part */
- if (i >= 65536)
- return 0;
- i <<= 16;
- continue;
- }
- if ((j == '-' || j == ':') && !last) {
- last++;
- if (i < 65536)
- i <<= 16;
- pattern->val.range.min = i;
- i = 0;
- continue;
+ /* If the separator is the first character. */
+ if (ptr == *text && *(ptr+1) != '\0') {
+ if (strl2llrc_dotted(ptr+1, strlen(ptr+1), &pattern->val.range.max) != 0) {
+ memprintf(err, "'%s' is not a valid dotted number range", *text);
+ return 0;
}
- j -= '0';
- if (j > 9)
- // also catches the terminating zero
- break;
- i = (i & 0xFFFF0000) + (i & 0xFFFF) * 10;
- i += j;
- }
-
- /* if we only got a major version, let's shift it now */
- if (i < 65536)
- i <<= 16;
-
- if (last && *opaque >= 1 && *opaque <= 4) {
- /* having a range with a min or a max is absurd */
- memprintf(err, "version range '%s' specified with a comparison operator", text[skip]);
- return 0;
+ pattern->val.range.min_set = 0;
+ pattern->val.range.max_set = 1;
+ return 1;
}
- pattern->expect_type = SMP_T_UINT;
-
- if (!last)
- pattern->val.range.min = i;
- pattern->val.range.max = i;
-
- switch (*opaque) {
- case 0: /* eq */
- pattern->val.range.min_set = 1;
- pattern->val.range.max_set = 1;
- break;
- case 1: /* gt */
- pattern->val.range.min++; /* gt = ge + 1 */
- case 2: /* ge */
+ /* If separator is the last character. */
+ if (ptr == &(*text)[strlen(*text)-1]) {
+ if (strl2llrc_dotted(*text, ptr-*text, &pattern->val.range.min) != 0) {
+ memprintf(err, "'%s' is not a valid dotted number range", *text);
+ return 0;
+ }
pattern->val.range.min_set = 1;
pattern->val.range.max_set = 0;
- break;
- case 3: /* lt */
- pattern->val.range.max--; /* lt = le - 1 */
- case 4: /* le */
- pattern->val.range.min_set = 0;
- pattern->val.range.max_set = 1;
- break;
+ return 1;
+ }
+
+ /* Else, parse two numbers. */
+ if (strl2llrc_dotted(*text, ptr-*text, &pattern->val.range.min) != 0) {
+ memprintf(err, "'%s' is not a valid dotted number range", *text);
+ return 0;
+ }
+ if (strl2llrc_dotted(ptr+1, strlen(ptr+1), &pattern->val.range.max) != 0) {
+ memprintf(err, "'%s' is not a valid dotted number range", *text);
+ return 0;
}
- return skip + 1;
+ if (pattern->val.range.min > pattern->val.range.max) {
+ memprintf(err, "'%s' is not a valid dotted number range", *text);
+ return 0;
+ }
+ pattern->val.range.min_set = 1;
+ pattern->val.range.max_set = 1;
+ return 1;
}
/* Parse an IP address and an optional mask in the form addr[/mask].
projects / thirdparty / haproxy.git / commitdiff
