#include "target.h" // For DM_ARRAY_SIZE! #include "libdevmapper.h" #include #include #include //---------------------------------------------------------------- static char *_tok_cpy(const char *b, const char *e) { char *new = malloc((e - b) + 1); char *ptr = new; if (new) { while (b != e) *ptr++ = *b++; *ptr = '\0'; } return new; } static bool _tok_eq(const char *b, const char *e, const char *str) { while (b != e) { if (!*str || *b != *str) return false; b++; str++; } return !*str; } static bool _parse_operating_mode(const char *b, const char *e, void *context) { static struct { const char *str; enum vdo_operating_mode mode; } _table[] = { {"recovering", VDO_MODE_RECOVERING}, {"read-only", VDO_MODE_READ_ONLY}, {"normal", VDO_MODE_NORMAL} }; enum vdo_operating_mode *r = context; unsigned i; for (i = 0; i < DM_ARRAY_SIZE(_table); i++) { if (_tok_eq(b, e, _table[i].str)) { *r = _table[i].mode; return true; } } return false; } static bool _parse_compression_state(const char *b, const char *e, void *context) { static struct { const char *str; enum vdo_compression_state state; } _table[] = { {"online", VDO_COMPRESSION_ONLINE}, {"offline", VDO_COMPRESSION_OFFLINE} }; enum vdo_compression_state *r = context; unsigned i; for (i = 0; i < DM_ARRAY_SIZE(_table); i++) { if (_tok_eq(b, e, _table[i].str)) { *r = _table[i].state; return true; } } return false; } static bool _parse_recovering(const char *b, const char *e, void *context) { bool *r = context; if (_tok_eq(b, e, "recovering")) *r = true; else if (_tok_eq(b, e, "-")) *r = false; else return false; return true; } static bool _parse_index_state(const char *b, const char *e, void *context) { static struct { const char *str; enum vdo_index_state state; } _table[] = { {"error", VDO_INDEX_ERROR}, {"closed", VDO_INDEX_CLOSED}, {"opening", VDO_INDEX_OPENING}, {"closing", VDO_INDEX_CLOSING}, {"offline", VDO_INDEX_OFFLINE}, {"online", VDO_INDEX_ONLINE}, {"unknown", VDO_INDEX_UNKNOWN} }; enum vdo_index_state *r = context; unsigned i; for (i = 0; i < DM_ARRAY_SIZE(_table); i++) { if (_tok_eq(b, e, _table[i].str)) { *r = _table[i].state; return true; } } return false; } static bool _parse_uint64(const char *b, const char *e, void *context) { uint64_t *r = context, n; n = 0; while (b != e) { if (!isdigit(*b)) return false; n = (n * 10) + (*b - '0'); b++; } *r = n; return true; } static const char *_eat_space(const char *b, const char *e) { while (b != e && isspace(*b)) b++; return b; } static const char *_next_tok(const char *b, const char *e) { const char *te = b; while (te != e && !isspace(*te)) te++; return te == b ? NULL : te; } static void _set_error(struct vdo_status_parse_result *result, const char *fmt, ...) __attribute__ ((format(printf, 2, 3))); static void _set_error(struct vdo_status_parse_result *result, const char *fmt, ...) { va_list ap; va_start(ap, fmt); vsnprintf(result->error, sizeof(result->error), fmt, ap); va_end(ap); } static bool _parse_field(const char **b, const char *e, bool (*p_fn)(const char *, const char *, void *), void *field, const char *field_name, struct vdo_status_parse_result *result) { const char *te; te = _next_tok(*b, e); if (!te) { _set_error(result, "couldn't get token for '%s'", field_name); return false; } if (!p_fn(*b, te, field)) { _set_error(result, "couldn't parse '%s'", field_name); return false; } *b = _eat_space(te, e); return true; } bool vdo_status_parse(const char *input, struct vdo_status_parse_result *result) { const char *b = b = input; const char *e = input + strlen(input); const char *te; struct vdo_status *s = malloc(sizeof(*s)); if (!s) { _set_error(result, "out of memory"); return false; } b = _eat_space(b, e); te = _next_tok(b, e); if (!te) { _set_error(result, "couldn't get token for device"); free(s); return false; } s->device = _tok_cpy(b, te); if (!s->device) { _set_error(result, "out of memory"); free(s); return false; } b = _eat_space(te, e); #define XX(p, f, fn) if (!_parse_field(&b, e, p, f, fn, result)) goto bad; XX(_parse_operating_mode, &s->operating_mode, "operating mode"); XX(_parse_recovering, &s->recovering, "recovering"); XX(_parse_index_state, &s->index_state, "index state"); XX(_parse_compression_state, &s->compression_state, "compression state"); XX(_parse_uint64, &s->used_blocks, "used blocks"); XX(_parse_uint64, &s->total_blocks, "total blocks"); #undef XX if (b != e) { _set_error(result, "too many tokens"); goto bad; } result->status = s; return true; bad: free(s->device); free(s); return false; } //----------------------------------------------------------------