int
keyword_alloc(vector keywords, char *string,
int (*handler) (struct config *, vector),
int (*print) (struct config *, char *, int, void *), int unique)
{
struct keyword *keyword;
keyword = (struct keyword *) MALLOC(sizeof (struct keyword));
if (!keyword)
return 1;
if (!vector_alloc_slot(keywords)) {
FREE(keyword);
return 1;
}
keyword->string = string;
keyword->handler = handler;
keyword->print = print;
keyword->unique = unique;
vector_set_slot(keywords, keyword);
return 0;
}
static int
add_key (vector vec, char * str, unsigned long code, int has_param)
{
struct key * kw;
kw = alloc_key();
if (!kw)
return 1;
kw->code = code;
kw->has_param = has_param;
kw->str = STRDUP(str);
if (!kw->str)
goto out;
if (!vector_alloc_slot(vec))
goto out1;
vector_set_slot(vec, kw);
return 0;
out1:
FREE(kw->str);
out:
FREE(kw);
return 1;
}
vector_t *
alloc_strvec(char *string)
{
char *cp, *start, *token;
size_t str_len;
vector_t *strvec;
if (!string)
return NULL;
cp = string;
/* Skip white spaces */
while (isspace((int) *cp) && *cp != '\0')
cp++;
/* Return if there is only white spaces */
if (*cp == '\0')
return NULL;
/* Return if string begin with a comment */
if (*cp == '!' || *cp == '#')
return NULL;
/* Create a vector and alloc each command piece */
strvec = vector_alloc();
while (1) {
start = cp;
/* Save a quoted string without the "s as a single string */
if (*cp == '"') {
start++;
if (!(cp = strchr(start, '"'))) {
log_message(LOG_INFO, "Unmatched quote: '%s'", string);
return strvec;
}
str_len = (size_t)(cp - start);
cp++;
} else {
while (!isspace((int) *cp) && *cp != '\0' && *cp != '"'
&& *cp != '!' && *cp != '#')
cp++;
str_len = (size_t)(cp - start);
}
token = MALLOC(str_len + 1);
memcpy(token, start, str_len);
token[str_len] = '\0';
/* Alloc & set the slot */
vector_alloc_slot(strvec);
vector_set_slot(strvec, token);
while (isspace((int) *cp) && *cp != '\0')
cp++;
if (*cp == '\0' || *cp == '!' || *cp == '#')
return strvec;
}
}
vector_t *
read_value_block(vector_t *strvec)
{
char *buf;
unsigned int word;
char *str = NULL;
char *dup;
vector_t *vec = NULL;
vector_t *elements = vector_alloc();
int first = 1;
int need_bob = 1;
int got_eob = 0;
buf = (char *) MALLOC(MAXBUF);
while (first || read_line(buf, MAXBUF)) {
if (first && vector_size(strvec) > 1) {
vec = strvec;
word = 1;
}
else {
vec = alloc_strvec(buf);
word = 0;
}
if (vec) {
str = vector_slot(vec, word);
if (need_bob) {
if (!strcmp(str, BOB))
word++;
else
log_message(LOG_INFO, "'{' missing at beginning of block %s", FMT_STR_VSLOT(strvec,0));
need_bob = 0;
}
for (; word < vector_size(vec); word++) {
str = vector_slot(vec, word);
if (!strcmp(str, EOB)) {
if (word != vector_size(vec) - 1)
log_message(LOG_INFO, "Extra characters after '}' - \"%s\"", buf);
got_eob = 1;
break;
}
dup = (char *) MALLOC(strlen(str) + 1);
memcpy(dup, str, strlen(str));
vector_alloc_slot(elements);
vector_set_slot(elements, dup);
}
if (vec != strvec)
free_strvec(vec);
if (got_eob)
break;
}
memset(buf, 0, MAXBUF);
first = 0;
}
FREE(buf);
return elements;
}
int
store_pathgroup (vector pgvec, struct pathgroup * pgp)
{
if (!vector_alloc_slot(pgvec))
return 1;
vector_set_slot(pgvec, pgp);
return 0;
}
int
store_path (vector pathvec, struct path * pp)
{
if (!vector_alloc_slot(pathvec))
return 1;
vector_set_slot(pathvec, pp);
return 0;
}
vector
read_value_block(void)
{
char *buf;
int i;
char *str = NULL;
char *dup;
vector vec = NULL;
vector elements = vector_alloc();
if (!elements)
return NULL;
buf = (char *) MALLOC(MAXBUF);
if (!buf)
return NULL;
while (read_line(buf, MAXBUF)) {
vec = alloc_strvec(buf);
if (vec) {
str = VECTOR_SLOT(vec, 0);
if (!strcmp(str, EOB)) {
free_strvec(vec);
break;
}
if (VECTOR_SIZE(vec))
for (i = 0; i < VECTOR_SIZE(vec); i++) {
str = VECTOR_SLOT(vec, i);
dup = (char *) MALLOC(strlen(str) + 1);
if (!dup)
goto out;
memcpy(dup, str, strlen(str));
if (!vector_alloc_slot(elements)) {
free_strvec(vec);
goto out1;
}
vector_set_slot(elements, dup);
}
free_strvec(vec);
}
memset(buf, 0, MAXBUF);
}
FREE(buf);
return elements;
out1:
FREE(dup);
out:
FREE(buf);
return NULL;
}
vector_t *
alloc_strvec(char *string)
{
char *cp, *start, *token;
int str_len;
vector_t *strvec;
if (!string)
return NULL;
cp = string;
/* Skip white spaces */
while (isspace((int) *cp) && *cp != '\0')
cp++;
/* Return if there is only white spaces */
if (*cp == '\0')
return NULL;
/* Return if string begin with a comment */
if (*cp == '!' || *cp == '#')
return NULL;
/* Create a vector and alloc each command piece */
strvec = vector_alloc();
while (1) {
start = cp;
if (*cp == '"') {
cp++;
token = MALLOC(2);
*(token) = '"';
*(token + 1) = '\0';
} else {
while (!isspace((int) *cp) && *cp != '\0' && *cp != '"')
cp++;
str_len = cp - start;
token = MALLOC(str_len + 1);
memcpy(token, start, str_len);
*(token + str_len) = '\0';
}
/* Alloc & set the slot */
vector_alloc_slot(strvec);
vector_set_slot(strvec, token);
while (isspace((int) *cp) && *cp != '\0')
cp++;
if (*cp == '\0' || *cp == '!' || *cp == '#')
return strvec;
}
}
void
keyword_alloc(vector_t *keywords_vec, char *string, void (*handler) (vector_t *))
{
keyword_t *keyword;
vector_alloc_slot(keywords_vec);
keyword = (keyword_t *) MALLOC(sizeof(keyword_t));
keyword->string = string;
keyword->handler = handler;
vector_set_slot(keywords_vec, keyword);
}
static void
keyword_alloc(vector_t *keywords_vec, const char *string, void (*handler) (vector_t *), bool active)
{
keyword_t *keyword;
vector_alloc_slot(keywords_vec);
keyword = (keyword_t *) MALLOC(sizeof(keyword_t));
keyword->string = string;
keyword->handler = (active) ? handler : NULL;
keyword->active = active;
vector_set_slot(keywords_vec, keyword);
}
static int
multipath_handler(struct config *conf, vector strvec)
{
struct mpentry * mpe;
mpe = alloc_mpe();
if (!mpe)
return 1;
if (!vector_alloc_slot(conf->mptable)) {
free_mpe(mpe);
return 1;
}
vector_set_slot(conf->mptable, mpe);
return 0;
}
static int
device_handler(struct config *conf, vector strvec)
{
struct hwentry * hwe;
hwe = alloc_hwe();
if (!hwe)
return 1;
if (!vector_alloc_slot(conf->hwtable)) {
free_hwe(hwe);
return 1;
}
vector_set_slot(conf->hwtable, hwe);
return 0;
}
int
add_handler (unsigned long fp, int (*fn)(void *, char **, int *, void *))
{
struct handler * h;
h = alloc_handler();
if (!h)
return 1;
if (!vector_alloc_slot(handlers)) {
FREE(h);
return 1;
}
vector_set_slot(handlers, h);
h->fingerprint = fp;
h->fn = fn;
return 0;
}
int warn_on_duplicates(vector uniques, char *str, char *file)
{
char *tmp;
int i;
vector_foreach_slot(uniques, tmp, i) {
if (!strcmp(str, tmp)) {
condlog(1, "%s line %d, duplicate keyword: %s",
file, line_nr, str);
return 0;
}
}
tmp = strdup(str);
if (!tmp)
return 1;
if (!vector_alloc_slot(uniques)) {
free(tmp);
return 1;
}
vector_set_slot(uniques, tmp);
return 0;
}
vector_t *
read_value_block(void)
{
char *buf;
int i;
char *str = NULL;
char *dup;
vector_t *vec = NULL;
vector_t *elements = vector_alloc();
buf = (char *) MALLOC(MAXBUF);
while (read_line(buf, MAXBUF)) {
vec = alloc_strvec(buf);
if (vec) {
str = vector_slot(vec, 0);
if (!strcmp(str, EOB)) {
free_strvec(vec);
break;
}
if (vector_size(vec))
for (i = 0; i < vector_size(vec); i++) {
str = vector_slot(vec, i);
dup = (char *) MALLOC(strlen(str) + 1);
memcpy(dup, str, strlen(str));
vector_alloc_slot(elements);
vector_set_slot(elements, dup);
}
free_strvec(vec);
}
memset(buf, 0, MAXBUF);
}
FREE(buf);
return elements;
}
int
store_hwe (vector hwtable, struct hwentry * dhwe)
{
struct hwentry * hwe;
if (find_hwe_strmatch(hwtable, dhwe))
return 0;
if (!(hwe = alloc_hwe()))
return 1;
if (!dhwe->vendor || !(hwe->vendor = set_param_str(dhwe->vendor)))
goto out;
if (!dhwe->product || !(hwe->product = set_param_str(dhwe->product)))
goto out;
if (dhwe->revision && !(hwe->revision = set_param_str(dhwe->revision)))
goto out;
if (dhwe->uid_attribute && !(hwe->uid_attribute = set_param_str(dhwe->uid_attribute)))
goto out;
if (dhwe->features && !(hwe->features = set_param_str(dhwe->features)))
goto out;
if (dhwe->hwhandler && !(hwe->hwhandler = set_param_str(dhwe->hwhandler)))
goto out;
if (dhwe->selector && !(hwe->selector = set_param_str(dhwe->selector)))
goto out;
if (dhwe->checker_name && !(hwe->checker_name = set_param_str(dhwe->checker_name)))
goto out;
if (dhwe->prio_name && !(hwe->prio_name = set_param_str(dhwe->prio_name)))
goto out;
if (dhwe->prio_args && !(hwe->prio_args = set_param_str(dhwe->prio_args)))
goto out;
if (dhwe->alias_prefix && !(hwe->alias_prefix = set_param_str(dhwe->alias_prefix)))
goto out;
hwe->pgpolicy = dhwe->pgpolicy;
hwe->pgfailback = dhwe->pgfailback;
hwe->rr_weight = dhwe->rr_weight;
hwe->no_path_retry = dhwe->no_path_retry;
hwe->minio = dhwe->minio;
hwe->minio_rq = dhwe->minio_rq;
hwe->pg_timeout = dhwe->pg_timeout;
hwe->flush_on_last_del = dhwe->flush_on_last_del;
hwe->fast_io_fail = dhwe->fast_io_fail;
hwe->dev_loss = dhwe->dev_loss;
hwe->user_friendly_names = dhwe->user_friendly_names;
hwe->retain_hwhandler = dhwe->retain_hwhandler;
hwe->detect_prio = dhwe->detect_prio;
if (dhwe->bl_product && !(hwe->bl_product = set_param_str(dhwe->bl_product)))
goto out;
if (!vector_alloc_slot(hwtable))
goto out;
vector_set_slot(hwtable, hwe);
return 0;
out:
free_hwe(hwe);
return 1;
}
vector
alloc_strvec(char *string)
{
char *cp, *start, *token;
int strlen;
int in_string;
vector strvec;
if (!string)
return NULL;
cp = string;
/* Skip white spaces */
while ((isspace((int) *cp) || !isascii((int) *cp)) && *cp != '\0')
cp++;
/* Return if there is only white spaces */
if (*cp == '\0')
return NULL;
/* Return if string begin with a comment */
if (*cp == '!' || *cp == '#')
return NULL;
/* Create a vector and alloc each command piece */
strvec = vector_alloc();
if (!strvec)
return NULL;
in_string = 0;
while (1) {
if (!vector_alloc_slot(strvec))
goto out;
start = cp;
if (*cp == '"') {
cp++;
token = MALLOC(2);
if (!token)
goto out;
*(token) = '"';
*(token + 1) = '\0';
if (in_string)
in_string = 0;
else
in_string = 1;
} else if (!in_string && (*cp == '{' || *cp == '}')) {
token = MALLOC(2);
if (!token)
goto out;
*(token) = *cp;
*(token + 1) = '\0';
cp++;
} else {
while ((in_string ||
(!isspace((int) *cp) && isascii((int) *cp) &&
*cp != '!' && *cp != '#' && *cp != '{' &&
*cp != '}')) && *cp != '\0' && *cp != '"')
cp++;
strlen = cp - start;
token = MALLOC(strlen + 1);
if (!token)
goto out;
memcpy(token, start, strlen);
*(token + strlen) = '\0';
}
vector_set_slot(strvec, token);
while ((isspace((int) *cp) || !isascii((int) *cp))
&& *cp != '\0')
cp++;
if (*cp == '\0' || *cp == '!' || *cp == '#')
return strvec;
}
out:
vector_free(strvec);
return NULL;
}
int
dm_get_maps (vector mp)
{
struct multipath * mpp;
int r = 1;
struct dm_task *dmt;
struct dm_names *names;
unsigned next = 0;
if (!mp)
return 1;
if (!(dmt = dm_task_create(DM_DEVICE_LIST)))
return 1;
dm_task_no_open_count(dmt);
if (!dm_task_run(dmt))
goto out;
if (!(names = dm_task_get_names(dmt)))
goto out;
if (!names->dev) {
r = 0; /* this is perfectly valid */
goto out;
}
do {
if (!dm_is_mpath(names->name))
goto next;
mpp = alloc_multipath();
if (!mpp)
goto out;
mpp->alias = STRDUP(names->name);
if (!mpp->alias)
goto out1;
if (dm_get_map(names->name, &mpp->size, NULL))
goto out1;
dm_get_uuid(names->name, mpp->wwid);
dm_get_info(names->name, &mpp->dmi);
if (!vector_alloc_slot(mp))
goto out1;
vector_set_slot(mp, mpp);
mpp = NULL;
next:
next = names->next;
names = (void *) names + next;
} while (next);
r = 0;
goto out;
out1:
free_multipath(mpp, KEEP_PATHS);
out:
dm_task_destroy (dmt);
return r;
}
static int
get_cmdvec (char * cmd, vector *v)
{
int i;
int r = 0;
int get_param = 0;
char * buff;
struct key * kw = NULL;
struct key * cmdkw = NULL;
vector cmdvec, strvec;
strvec = alloc_strvec(cmd);
if (!strvec)
return E_NOMEM;
cmdvec = vector_alloc();
if (!cmdvec) {
free_strvec(strvec);
return E_NOMEM;
}
vector_foreach_slot(strvec, buff, i) {
if (*buff == '"')
continue;
if (get_param) {
get_param = 0;
cmdkw->param = strdup(buff);
continue;
}
kw = find_key(buff);
if (!kw) {
r = E_SYNTAX;
goto out;
}
cmdkw = alloc_key();
if (!cmdkw) {
r = E_NOMEM;
goto out;
}
if (!vector_alloc_slot(cmdvec)) {
FREE(cmdkw);
r = E_NOMEM;
goto out;
}
vector_set_slot(cmdvec, cmdkw);
cmdkw->code = kw->code;
cmdkw->has_param = kw->has_param;
if (kw->has_param)
get_param = 1;
}
if (get_param) {
r = E_NOPARM;
goto out;
}
*v = cmdvec;
free_strvec(strvec);
return 0;
out:
free_strvec(strvec);
free_keys(cmdvec);
return r;
}