X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=blob.c;h=8675ee73330fb1f87a1f4ef0a2780b445a2a7b5b;hp=031f6ae3a76c2e29cd429135f3b73e60c8bc38d8;hb=51dde9efab2d662cf5813d26d5c9aebce6e197e7;hpb=0496a19e8ac1afecde726c2292720d415bdb7500 diff --git a/blob.c b/blob.c index 031f6ae3..8675ee73 100644 --- a/blob.c +++ b/blob.c @@ -9,9 +9,9 @@ #include #include "para.h" #include "error.h" +#include "string.h" #include "afh.h" #include "afs.h" -#include "string.h" #include "net.h" static struct osl_column_description blob_cols[] = { @@ -53,109 +53,64 @@ enum blob_ls_flags { }; /** Structure passed to the \p print_blob function. */ -struct lsblob_data { +struct lsblob_action_data { + /* The flags given at the command line. */ uint32_t flags; + /** Message buffer. */ struct para_buffer pb; }; -static int print_blob(struct osl_table *table, struct osl_row *row, const char *name, void *data) +static int print_blob(struct osl_table *table, struct osl_row *row, + const char *name, void *data) { + struct lsblob_action_data *lbad = data; struct osl_object obj; uint32_t id; int ret; - struct lsblob_data *lbd = data; - if (!(lbd->flags & BLOB_LS_FLAG_LONG)) { - para_printf(&lbd->pb, "%s\n", name); + if (!(lbad->flags & BLOB_LS_FLAG_LONG)) { + para_printf(&lbad->pb, "%s\n", name); return 1; } ret = osl_get_object(table, row, BLOBCOL_ID, &obj); - if (ret < 0) - return ret; - id = *(uint32_t *)obj.data; - para_printf(&lbd->pb, "%u\t%s\n", id, name); - return 1; -} - -enum blob_match_loop_flags { - BM_NAME_LOOP = 1, - BM_REVERSE_LOOP = 2 -}; - -struct blob_match_data { - struct osl_table *table; - const char *patterns; - size_t patterns_size; - int fnmatch_flags; - unsigned loop_flags; - void *data; - int (*action)(struct osl_table *table, struct osl_row *row, const char *name, void *data); -}; - -static int action_if_blob_matches(struct osl_row *row, void *data) -{ - struct blob_match_data *bmd = data; - struct osl_object name_obj; - const char *p, *name; - int ret = osl_get_object(bmd->table, row, BLOBCOL_NAME, &name_obj); - if (ret < 0) { - PARA_ERROR_LOG("%s\n", PARA_STRERROR(-ret)); + para_printf(&lbad->pb, "%s: %s\n", name, PARA_STRERROR(-ret)); return ret; } - name = (char *)name_obj.data; - if (!*name) /* ignore dummy row */ - return 1; - if (!bmd->patterns_size) /* match everything if no pattern was given */ - return bmd->action(bmd->table, row, name, bmd->data); - for (p = bmd->patterns; p < bmd->patterns + bmd->patterns_size; - p += strlen(p) + 1) { - ret = fnmatch(p, name, bmd->fnmatch_flags); - if (ret == FNM_NOMATCH) - continue; - if (ret) - return -E_FNMATCH; - return bmd->action(bmd->table, row, name, bmd->data); - } + id = *(uint32_t *)obj.data; + para_printf(&lbad->pb, "%u\t%s\n", id, name); return 1; } -static int for_each_matching_blob(struct blob_match_data *bmd) -{ - unsigned col = (bmd->loop_flags & BM_NAME_LOOP)? - BLOBCOL_NAME : BLOBCOL_ID; - - if (bmd->loop_flags & BM_REVERSE_LOOP) - return osl_rbtree_loop_reverse(bmd->table, col, bmd, action_if_blob_matches); - return osl_rbtree_loop(bmd->table, col, bmd, action_if_blob_matches); -} - -int com_lsblob_callback(struct osl_table *table, - const struct osl_object *query, struct osl_object *ls_output) +static int com_lsblob_callback(struct osl_table *table, + const struct osl_object *query, struct osl_object *result) { - struct lsblob_data lbd = {.flags = *(uint32_t *)query}; - struct blob_match_data bmd = { + struct lsblob_action_data lbad = {.flags = *(uint32_t *)query->data}; + struct pattern_match_data pmd = { .table = table, - .patterns = (char *)query->data + sizeof(uint32_t), - .patterns_size = query->size - sizeof(uint32_t), - .data = &lbd, - .action = print_blob + .patterns = {.data = (char *)query->data + sizeof(uint32_t), + .size = query->size - sizeof(uint32_t)}, + .pm_flags = PM_NO_PATTERN_MATCHES_EVERYTHING | PM_SKIP_EMPTY_NAME, + .match_col_num = BLOBCOL_NAME, + .data = &lbad, + .action = print_blob, }; int ret; - if (lbd.flags & BLOB_LS_FLAG_REVERSE) - bmd.loop_flags |= BM_REVERSE_LOOP; - if (!(lbd.flags & BLOB_LS_FLAG_SORT_BY_ID)) - bmd.loop_flags |= BM_NAME_LOOP; - ret = for_each_matching_blob(&bmd); - if (lbd.pb.buf) { - ls_output->data = lbd.pb.buf; - ls_output->size = lbd.pb.size; - return 1; - } - if (ret > 0) - ret = 0; - return ret; + if (lbad.flags & BLOB_LS_FLAG_REVERSE) + pmd.pm_flags |= PM_REVERSE_LOOP; + if (!(lbad.flags & BLOB_LS_FLAG_SORT_BY_ID)) + pmd.loop_col_num = BLOBCOL_NAME; + else + pmd.loop_col_num = BLOBCOL_ID; + ret = for_each_matching_row(&pmd); + if (ret < 0) + para_printf(&lbad.pb, "%s\n", PARA_STRERROR(-ret)); + if (!lbad.pb.buf) + return 0; + result->data = lbad.pb.buf; + result->size = lbad.pb.size; + return 1; } static int com_lsblob(callback_function *f, int fd, int argc, char * const * const argv) @@ -185,6 +140,7 @@ static int com_lsblob(callback_function *f, int fd, int argc, char * const * con flags |= BLOB_LS_FLAG_REVERSE; continue; } + break; } // if (argc > i) // return -E_BLOB_SYNTAX; @@ -219,15 +175,17 @@ static int com_catblob_callback(struct osl_table *table, const struct osl_object *query, struct osl_object *result) { int ret; - struct blob_match_data bmd = { + struct pattern_match_data pmd = { .table = table, - .patterns = (char *)query->data, - .patterns_size = query->size, + .patterns = *query, + .loop_col_num = BLOBCOL_NAME, + .match_col_num = BLOBCOL_NAME, + .pm_flags = PM_SKIP_EMPTY_NAME, .data = result, .action = cat_blob }; result->data = NULL; - ret = for_each_matching_blob(&bmd); + ret = for_each_matching_row(&pmd); if (result->data) return 1; return (ret > 0)? 0 : ret; @@ -249,8 +207,11 @@ static int com_catblob(callback_function *f, int fd, int argc, return ret; } +/** Used for removing rows from a blob table. */ struct rmblob_data { + /** Message buffer. */ struct para_buffer pb; + /** Number of removed blobs. */ unsigned num_removed; }; @@ -269,31 +230,35 @@ static int remove_blob(struct osl_table *table, struct osl_row *row, static int com_rmblob_callback(struct osl_table *table, const struct osl_object *query, - __a_unused struct osl_object *result) + struct osl_object *result) { int ret; struct rmblob_data rmbd = {.num_removed = 0}; - struct blob_match_data bmd = { + struct pattern_match_data pmd = { .table = table, - .patterns = (char *)query->data, - .patterns_size = query->size, + .patterns = *query, + .loop_col_num = BLOBCOL_NAME, + .match_col_num = BLOBCOL_NAME, + .pm_flags = PM_SKIP_EMPTY_NAME, .data = &rmbd, .action = remove_blob }; result->data = NULL; - ret = for_each_matching_blob(&bmd); + ret = for_each_matching_row(&pmd); if (ret < 0) para_printf(&rmbd.pb, "%s\n", PARA_STRERROR(-ret)); if (!rmbd.num_removed) para_printf(&rmbd.pb, "no matches, nothing removed\n"); - else + else { para_printf(&rmbd.pb, "removed %d blobs\n", rmbd.num_removed); + afs_event(BLOB_RENAME, NULL, table); + } result->data = rmbd.pb.buf; result->size = rmbd.pb.size; return 1; } -static int com_rmblob(callback_function *f, __a_unused int fd, int argc, +static int com_rmblob(callback_function *f, int fd, int argc, char * const * const argv) { int ret; @@ -370,7 +335,11 @@ static int com_addblob_callback(struct osl_table *table, objs[BLOBCOL_NAME].size = name_len; objs[BLOBCOL_DEF].data = name + name_len; objs[BLOBCOL_DEF].size = query->size - name_len; - return osl_add_row(table, objs); + ret = osl_add_row(table, objs); + if (ret < 0) + return ret; + afs_event(BLOB_ADD, NULL, table); + return 1; } static int com_addblob(callback_function *f, int fd, int argc, @@ -402,10 +371,14 @@ static int com_mvblob_callback(struct osl_table *table, return ret; obj.data = dest; obj.size = strlen(dest) + 1; - return osl_update_object(table, row, BLOBCOL_NAME, &obj); + ret = osl_update_object(table, row, BLOBCOL_NAME, &obj); + if (ret < 0) + return ret; + afs_event(BLOB_RENAME, NULL, table); + return 1; } -static int com_mvblob(callback_function *f, __a_unused int fd, +static int com_mvblob(callback_function *f, __a_unused int fd, int argc, char * const * const argv) { if (argc != 3) @@ -452,6 +425,53 @@ static int blob_get_name_by_id(struct osl_table *table, uint32_t id, return blob_get_name_by_id(table_name ## _table, id, name); \ } + +static int blob_get_def_by_name(struct osl_table *table, char *name, + struct osl_object *def) +{ + struct osl_row *row; + struct osl_object obj = {.data = name, .size = strlen(name) + 1}; + int ret; + + def->data = NULL; + if (!*name) + return 1; + ret = osl_get_row(table, BLOBCOL_NAME, &obj, &row); + if (ret < 0) + return ret; + return osl_open_disk_object(table, row, BLOBCOL_DEF, def); +} + +/** Define the \p get_def_by_id function for this blob type. */ +#define DEFINE_GET_DEF_BY_NAME(table_name, cmd_prefix) \ + int cmd_prefix ## _get_def_by_name(char *name, struct osl_object *def) \ + { \ + return blob_get_def_by_name(table_name ## _table, name, def); \ + } + +static int blob_get_def_by_id(struct osl_table *table, uint32_t id, + struct osl_object *def) +{ + struct osl_row *row; + struct osl_object obj = {.data = &id, .size = sizeof(id)}; + int ret; + + def->data = NULL; + if (!id) + return 1; + ret = osl_get_row(table, BLOBCOL_ID, &obj, &row); + if (ret < 0) + return ret; + return osl_open_disk_object(table, row, BLOBCOL_DEF, def); +} + +/** Define the \p get_def_by_id function for this blob type. */ +#define DEFINE_GET_DEF_BY_ID(table_name, cmd_prefix) \ + int cmd_prefix ## _get_def_by_id(uint32_t id, struct osl_object *def) \ + { \ + return blob_get_def_by_id(table_name ## _table, id, def); \ + } + static int blob_get_name_and_def_by_row(struct osl_table *table, const struct osl_row *row, char **name, struct osl_object *def) { @@ -471,48 +491,73 @@ static int blob_get_name_and_def_by_row(struct osl_table *table, row, name, def); \ } -/** Define the \p shutdown function for this blob type. */ -#define DEFINE_BLOB_SHUTDOWN(table_name) \ - void table_name ## _shutdown(enum osl_close_flags flags) \ +/** Define the \p close function for this blob type. */ +#define DEFINE_BLOB_CLOSE(table_name) \ + void table_name ## _close(void) \ { \ - osl_close_table(table_name ## _table, flags); \ + osl_close_table(table_name ## _table, OSL_MARK_CLEAN); \ table_name ## _table = NULL; \ } -static int blob_init(struct osl_table **table, +/** Define the \p create function for this blob type. */ +#define DEFINE_BLOB_CREATE(table_name) \ + int table_name ## _create(const char *dir) \ + { \ + table_name ## _table_desc.dir = dir; \ + return osl_create_table(&table_name ## _table_desc); \ + } + +static int blob_open(struct osl_table **table, struct osl_table_description *desc, - struct table_info *ti, const char *db) + const char *dir) { int ret; - desc->dir = db; - ti->desc = desc; - ret = osl_open_table(ti->desc, table); + desc->dir = dir; + ret = osl_open_table(desc, table); if (ret >= 0) return ret; *table = NULL; - return ret == -E_NOENT? 1 : ret; + if (ret >= 0 || is_errno(-ret, ENOENT)) + return 1; + return ret; } +#define DEFINE_BLOB_OPEN(table_name) \ + int table_name ## _open(const char *dir) \ + { \ + return blob_open(&table_name ## _table, \ + &table_name ## _table_desc, dir); \ + } + + /** Define the \p init function for this blob type. */ #define DEFINE_BLOB_INIT(table_name) \ - int table_name ## _init(struct table_info *ti, const char *db) \ + void table_name ## _init(struct afs_table *t) \ { \ - return blob_init(&table_name ## _table, \ - &table_name ## _table_desc, ti, db); \ + t->name = table_name ## _table_desc.name; \ + t->open = table_name ## _open; \ + t->close = table_name ## _close; \ + t->create = table_name ## _create;\ + t->event_handler = table_name ##_event_handler; \ + table_name ## _table = NULL; \ } /** Define all functions for this blob type. */ #define DEFINE_BLOB_FUNCTIONS(table_name, cmd_prefix) \ + DEFINE_BLOB_OPEN(table_name) \ + DEFINE_BLOB_CLOSE(table_name) \ + DEFINE_BLOB_CREATE(table_name) \ + DEFINE_BLOB_INIT(table_name) \ DEFINE_BLOB_COMMAND(ls, table_name, cmd_prefix) \ DEFINE_BLOB_COMMAND(cat, table_name, cmd_prefix) \ DEFINE_BLOB_COMMAND(add, table_name, cmd_prefix) \ DEFINE_BLOB_COMMAND(rm, table_name, cmd_prefix) \ DEFINE_BLOB_COMMAND(mv, table_name, cmd_prefix) \ DEFINE_GET_NAME_BY_ID(table_name, cmd_prefix); \ + DEFINE_GET_DEF_BY_ID(table_name, cmd_prefix); \ + DEFINE_GET_DEF_BY_NAME(table_name, cmd_prefix); \ DEFINE_GET_NAME_AND_DEF_BY_ROW(table_name, cmd_prefix); \ - DEFINE_BLOB_SHUTDOWN(table_name); \ - DEFINE_BLOB_INIT(table_name); /** \cond doxygen isn't smart enough to recognize these */ DEFINE_BLOB_FUNCTIONS(lyrics, lyr);