MEDIUM: add a new typed argument list parsing framework
make_arg_list() builds an array of typed arguments with their values,
that the caller describes how to parse. This will be used to support
multiple arguments for ACLs and patterns, which is currently problematic
and prevents ACLs and patterns from being merged. Up to 7 arguments types
may be enumerated in a single 32-bit word, including their number of
mandatory parts.
At the moment, these files are not used yet, they're only built. Note that
the 4-bit encoding for the type has left only one unused type!
diff --git a/src/arg.c b/src/arg.c
new file mode 100644
index 0000000..0e11c49
--- /dev/null
+++ b/src/arg.c
@@ -0,0 +1,251 @@
+/*
+ * Functions used to parse typed argument lists
+ *
+ * Copyright 2012 Willy Tarreau <w@1wt.eu>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ */
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+
+#include <common/standard.h>
+#include <proto/arg.h>
+
+static const char *arg_type_names[ARGT_NBTYPES] = {
+ [ARGT_STOP] = "end of arguments",
+ [ARGT_UINT] = "unsigned integer",
+ [ARGT_SINT] = "signed integer",
+ [ARGT_STR] = "string",
+ [ARGT_IPV4] = "IPv4 address",
+ [ARGT_MSK4] = "IPv4 mask",
+ [ARGT_IPV6] = "IPv6 address",
+ [ARGT_MSK6] = "IPv6 mask",
+ [ARGT_TIME] = "delay",
+ [ARGT_SIZE] = "size",
+ [ARGT_FE] = "frontend",
+ [ARGT_BE] = "backend",
+ [ARGT_TAB] = "table",
+ [ARGT_SRV] = "server",
+ [ARGT_USR] = "user list",
+ /* Unassigned types must never happen. Better crash during parsing if they do. */
+};
+
+/* This function builds an argument list from a config line. It returns the
+ * number of arguments found, or <0 in case of any error. Everything needed
+ * it automatically allocated. A pointer to an error message might be returned
+ * in err_msg if not NULL, in which case it would be allocated and the caller
+ * will have to check it and free it. The output arg list is returned in argp
+ * which must be valid. The returned array is always terminated by an arg of
+ * type ARGT_STOP (0), unless the mask indicates that no argument is supported.
+ * The mask is composed of a number of mandatory arguments in its lower 4 bits,
+ * and a concatenation of each argument type in each subsequent 4-bit block. If
+ * <err_msg> is not NULL, it must point to a freeable or NULL pointer.
+ */
+int make_arg_list(const char *in, int len, unsigned int mask, struct arg **argp,
+ char **err_msg, const char **err_ptr, int *err_arg)
+{
+ int nbarg;
+ int pos;
+ struct arg *arg, *arg_list = NULL;
+ const char *beg;
+ char *word = NULL;
+ const char *ptr_err = NULL;
+ int min_arg;
+
+ min_arg = mask & 15;
+ mask >>= 4;
+
+ pos = 0;
+ /* find between 0 and 8 the max number of args supported by the mask */
+ for (nbarg = 0; nbarg < 8 && ((mask >> (nbarg * 4)) & 0xF); nbarg++);
+
+ if (!nbarg)
+ goto end_parse;
+
+ /* Note: an empty input string contains an empty argument if this argument
+ * is marked mandatory. Otherwise we can ignore it.
+ */
+ if (!len && !min_arg)
+ goto end_parse;
+
+ arg = arg_list = calloc(nbarg + 1, sizeof(*arg));
+
+ /* Note: empty arguments after a comma always exist. */
+ while (pos < nbarg) {
+ beg = in;
+ while (len && *in != ',') {
+ in++;
+ len--;
+ }
+
+ /* we have a new argument between <beg> and <in> (not included).
+ * For ease of handling, we copy it into a zero-terminated word.
+ * By default, the output argument will be the same type of the
+ * expected one.
+ */
+ free(word);
+ word = my_strndup(beg, in - beg);
+
+ arg->type = (mask >> (pos * 4)) & 15;
+
+ switch (arg->type) {
+ case ARGT_SINT:
+ if (in == beg) // empty number
+ goto parse_err;
+ else if (*beg < '0' || *beg > '9') {
+ arg->data.sint = strl2uic(beg + 1, in - beg - 1);
+ if (*beg == '-')
+ arg->data.sint = -arg->data.sint;
+ else if (*beg != '+') // invalid first character
+ goto parse_err;
+ break;
+ }
+
+ arg->type = ARGT_UINT;
+ /* fall through ARGT_UINT if no sign is present */
+
+ case ARGT_UINT:
+ if (in == beg) // empty number
+ goto parse_err;
+
+ arg->data.uint = strl2uic(beg, in - beg);
+ break;
+
+ case ARGT_FE:
+ case ARGT_BE:
+ case ARGT_TAB:
+ case ARGT_SRV:
+ case ARGT_USR:
+ case ARGT_STR:
+ /* all types that must be resolved are stored as strings
+ * during the parsing. The caller must at one point resolve
+ * them and free the string.
+ */
+ arg->data.str.str = word;
+ arg->data.str.len = in - beg;
+ arg->data.str.size = arg->data.str.len + 1;
+ word = NULL;
+ break;
+
+ case ARGT_IPV4:
+ if (in == beg) // empty address
+ goto parse_err;
+
+ if (inet_pton(AF_INET, word, &arg->data.ipv4) <= 0)
+ goto parse_err;
+ break;
+
+ case ARGT_MSK4:
+ if (in == beg) // empty mask
+ goto parse_err;
+
+ if (!str2mask(word, &arg->data.ipv4))
+ goto parse_err;
+
+ arg->type = ARGT_IPV4;
+ break;
+
+ case ARGT_IPV6:
+ if (in == beg) // empty address
+ goto parse_err;
+
+ if (inet_pton(AF_INET6, word, &arg->data.ipv6) <= 0)
+ goto parse_err;
+ break;
+
+ case ARGT_MSK6: /* not yet implemented */
+ goto parse_err;
+
+ case ARGT_TIME:
+ if (in == beg) // empty time
+ goto parse_err;
+
+ ptr_err = parse_time_err(word, &arg->data.uint, TIME_UNIT_MS);
+ if (ptr_err)
+ goto parse_err;
+
+ arg->type = ARGT_UINT;
+ break;
+
+ case ARGT_SIZE:
+ if (in == beg) // empty size
+ goto parse_err;
+
+ ptr_err = parse_size_err(word, &arg->data.uint);
+ if (ptr_err)
+ goto parse_err;
+
+ arg->type = ARGT_UINT;
+ break;
+
+ /* FIXME: other types need to be implemented here */
+ default:
+ goto parse_err;
+ }
+
+ pos++;
+ arg++;
+
+ /* don't go back to parsing if we reached end */
+ if (!len || pos >= nbarg)
+ break;
+
+ /* skip comma */
+ in++; len--;
+ }
+
+ end_parse:
+ free(word); word = NULL;
+
+ if (pos < min_arg) {
+ /* not enough arguments */
+ if (err_msg)
+ memprintf(err_msg,
+ "Missing arguments (got %d/%d), type '%s' expected",
+ pos, min_arg, arg_type_names[(mask >> (pos * 4)) & 15]);
+ goto err;
+ }
+
+ if (len) {
+ /* too many arguments, starting at <in> */
+ if (err_msg) {
+ /* the caller is responsible for freeing this message */
+ word = my_strndup(in, len);
+ memprintf(err_msg, "End of arguments expected at '%s'", word);
+ free(word); word = NULL;
+ }
+ goto err;
+ }
+
+ /* note that pos might be < nbarg and this is not an error, it's up to the
+ * caller to decide what to do with optional args.
+ */
+ *argp = arg_list;
+
+ if (err_arg)
+ *err_arg = pos;
+ if (err_ptr)
+ *err_ptr = in;
+ return pos;
+
+ parse_err:
+ if (err_msg) {
+ memprintf(err_msg, "Failed to parse '%s' as type '%s'",
+ word, arg_type_names[(mask >> (pos * 4)) & 15]);
+ }
+
+ err:
+ free(word);
+ free(arg_list);
+ if (err_arg)
+ *err_arg = pos;
+ if (err_ptr)
+ *err_ptr = in;
+ return -1;
+}