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; }
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; }
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; }
/* Insert a value into a specific slot */ void vector_insert_slot(vector v, int slot, void *value) { int i; vector_alloc_slot(v); for (i = (v->allocated / VECTOR_DEFAULT_SIZE) - 2; i >= slot; i--) v->slot[i + 1] = v->slot[i]; v->slot[slot] = value; }
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; } }
/* Insert a value into a specific slot */ void vector_insert_slot(vector v, unsigned int slot, void *value) { /* fix it */ #if 1 unsigned int i; vector_alloc_slot(v); for (i = (v->allocated / VECTOR_DEFAULT_SIZE) - 2; i >= slot; i--) v->slot[i + 1] = v->slot[i]; v->slot[slot] = value; #endif }
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; }