X-Git-Url: http://git.tuebingen.mpg.de/?a=blobdiff_plain;f=blob.c;h=4ecbc45bb15f42c15342e7900f4de94522ef45bb;hb=b3c68fd8519a426d6b6285dcb5a865670285e99a;hp=031f6ae3a76c2e29cd429135f3b73e60c8bc38d8;hpb=0496a19e8ac1afecde726c2292720d415bdb7500;p=paraslash.git

diff --git a/blob.c b/blob.c
index 031f6ae3..4ecbc45b 100644
--- a/blob.c
+++ b/blob.c
@@ -1,18 +1,43 @@
-/*
- * Copyright (C) 2007 Andre Noll <maan@systemlinux.org>
- *
- * Licensed under the GPL v2. For licencing details see COPYING.
- */
+/* Copyright (C) 2007 Andre Noll <maan@tuebingen.mpg.de>, see file COPYING. */
 
 /** \file blob.c Macros and functions for blob handling. */
 
+#include <regex.h>
 #include <fnmatch.h>
+#include <osl.h>
+#include <lopsub.h>
+
+#include "server_cmd.lsg.h"
 #include "para.h"
 #include "error.h"
+#include "crypt.h"
+#include "string.h"
 #include "afh.h"
 #include "afs.h"
-#include "string.h"
-#include "net.h"
+#include "ipc.h"
+#include "portable_io.h"
+#include "sideband.h"
+#include "command.h"
+
+/**
+ * Compare two osl objects pointing to unsigned integers of 32 bit size.
+ *
+ * \param obj1 Pointer to the first integer.
+ * \param obj2 Pointer to the second integer.
+ *
+ * \return The values required for an osl compare function.
+ */
+static int uint32_compare(const struct osl_object *obj1, const struct osl_object *obj2)
+{
+	uint32_t d1 = read_u32(obj1->data);
+	uint32_t d2 = read_u32(obj2->data);
+
+	if (d1 < d2)
+		return 1;
+	if (d1 > d2)
+		return -1;
+	return 0;
+}
 
 static struct osl_column_description blob_cols[] = {
 	[BLOBCOL_ID] = {
@@ -35,395 +60,434 @@ static struct osl_column_description blob_cols[] = {
 	}
 };
 
-/** \cond doxygen isn't smart enough to recognize these */
+/** Define an osl table description for a blob table. */
+#define DEFINE_BLOB_TABLE_DESC(table_name) \
+	static struct osl_table_description table_name ## _table_desc = { \
+		.name = #table_name, \
+		.num_columns = NUM_BLOB_COLUMNS, \
+		.flags = OSL_LARGE_TABLE, \
+		.column_descriptions = blob_cols \
+	};
+
+/** Define a pointer to an osl blob table with a canonical name. */
+#define DEFINE_BLOB_TABLE_PTR(table_name) struct osl_table *table_name ## _table;
+
+/** Define a blob table. */
+#define INIT_BLOB_TABLE(table_name) \
+	DEFINE_BLOB_TABLE_DESC(table_name); \
+	DEFINE_BLOB_TABLE_PTR(table_name);
+
+/* doxygen isn't smart enough to recognize these */
+/** \cond blob_table */
 INIT_BLOB_TABLE(lyrics);
 INIT_BLOB_TABLE(images);
 INIT_BLOB_TABLE(moods);
 INIT_BLOB_TABLE(playlists);
-/** \endcond */
-
-/** Flags that may be passed to the \p ls functions of each blob  type. */
-enum blob_ls_flags {
-	/** List both id and name. */
-	BLOB_LS_FLAG_LONG = 1,
-	/** Reverse sort order. */
-	BLOB_LS_FLAG_REVERSE = 2,
-	/** Sort by id instead of name. */
-	BLOB_LS_FLAG_SORT_BY_ID = 4,
-};
-
-/** Structure passed to the \p print_blob function. */
-struct lsblob_data {
-	uint32_t flags;
-	struct para_buffer pb;
-};
+/** \endcond blob_table */
 
-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 afs_callback_arg *aca = data;
+	bool l_given = SERVER_CMD_OPT_GIVEN(LSMOOD, LONG, aca->lpr);
 	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);
-		return 1;
+	if (!l_given) {
+		para_printf(&aca->pbout, "%s\n", name);
+		return 0;
 	}
-	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);
-
+	ret = osl(osl_get_object(table, row, BLOBCOL_ID, &obj));
 	if (ret < 0) {
-		PARA_ERROR_LOG("%s\n", PARA_STRERROR(-ret));
+		para_printf(&aca->pbout, "cannot list %s\n", name);
 		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 = read_u32(obj.data);
+	para_printf(&aca->pbout, "%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(const struct lls_command * const cmd,
+		struct osl_table *table, struct afs_callback_arg *aca)
 {
-	struct lsblob_data lbd = {.flags = *(uint32_t *)query};
-	struct blob_match_data bmd = {
+	bool i_given, r_given;
+	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
+		.pm_flags = PM_NO_PATTERN_MATCHES_EVERYTHING | PM_SKIP_EMPTY_NAME,
+		.match_col_num = BLOBCOL_NAME,
+		.data = aca,
+		.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;
+	ret = lls_deserialize_parse_result(aca->query.data, cmd, &aca->lpr);
+	pmd.lpr = aca->lpr;
+	assert(ret >= 0);
+	i_given = SERVER_CMD_OPT_GIVEN(LSMOOD, ID_SORT, aca->lpr);
+	r_given = SERVER_CMD_OPT_GIVEN(LSMOOD, REVERSE, aca->lpr);
+
+	if (r_given)
+		pmd.pm_flags |= PM_REVERSE_LOOP;
+	if (i_given)
+		pmd.loop_col_num = BLOBCOL_ID;
+	else
+		pmd.loop_col_num = BLOBCOL_NAME;
+	ret = for_each_matching_row(&pmd);
+	if (ret < 0)
+		goto out;
+	if (pmd.num_matches == 0 && lls_num_inputs(aca->lpr) > 0)
+		ret = -E_NO_MATCH;
+out:
+	lls_free_parse_result(aca->lpr, cmd);
 	return ret;
 }
 
-static int com_lsblob(callback_function *f, int fd, int argc, char * const * const argv)
+static int com_lsblob(afs_callback *f, const struct lls_command * const cmd,
+		struct command_context *cc, struct lls_parse_result *lpr)
 {
-	uint32_t flags = 0;
-	struct osl_object options = {.data = &flags, .size = sizeof(flags)},
-		result;
-	int i, ret;
-
-	for (i = 1; i < argc; i++) {
-		const char *arg = argv[i];
-		if (arg[0] != '-')
-			break;
-		if (!strcmp(arg, "--")) {
-			i++;
-			break;
-		}
-		if (!strcmp(arg, "-l")) {
-			flags |= BLOB_LS_FLAG_LONG;
-			continue;
-		}
-		if (!strcmp(arg, "-i")) {
-			flags |= BLOB_LS_FLAG_SORT_BY_ID;
-			continue;
-		}
-		if (!strcmp(arg, "-r")) {
-			flags |= BLOB_LS_FLAG_REVERSE;
-			continue;
-		}
-	}
-//	if (argc > i)
-//		return -E_BLOB_SYNTAX;
-	ret = send_option_arg_callback_request(&options, argc - i,
-		argv + i, f, &result);
-	if (ret > 0) {
-		send_buffer(fd, (char *)result.data);
-		free(result.data);
-	}
-	return ret;
+	return send_lls_callback_request(f, cmd, lpr, cc);
 }
 
 static int cat_blob(struct osl_table *table, struct osl_row *row,
 		__a_unused const char *name, void *data)
 {
-	int ret;
-	struct osl_object *blobs = data;
+	int ret = 0, ret2, fd = *(int *)data;
 	struct osl_object obj;
 
-	ret = osl_open_disk_object(table, row, BLOBCOL_DEF, &obj);
+	ret = osl(osl_open_disk_object(table, row, BLOBCOL_DEF, &obj));
 	if (ret < 0)
-		return ret;
-	if (obj.size) {
-		blobs->data = para_realloc(blobs->data, blobs->size + obj.size);
-		memcpy(blobs->data + blobs->size, obj.data, obj.size);
-		blobs->size += obj.size;
-	}
-	return osl_close_disk_object(&obj);
+		return (ret == osl(-E_OSL_EMPTY))? 0 : ret;
+	assert(obj.size > 0);
+	ret = pass_buffer_as_shm(fd, SBD_OUTPUT, obj.data, obj.size);
+	ret2 = osl(osl_close_disk_object(&obj));
+	return (ret < 0)? ret : ret2;
 }
 
-static int com_catblob_callback(struct osl_table *table,
-		const struct osl_object *query, struct osl_object *result)
+static int com_catblob_callback(const struct lls_command * const cmd,
+		struct osl_table *table, struct afs_callback_arg *aca)
 {
 	int ret;
-	struct blob_match_data bmd = {
+	struct pattern_match_data pmd = {
 		.table = table,
-		.patterns = (char *)query->data,
-		.patterns_size = query->size,
-		.data = result,
+		.loop_col_num = BLOBCOL_NAME,
+		.match_col_num = BLOBCOL_NAME,
+		.pm_flags = PM_SKIP_EMPTY_NAME,
+		.data = &aca->fd,
 		.action = cat_blob
 	};
-	result->data = NULL;
-	ret = for_each_matching_blob(&bmd);
-	if (result->data)
-		return 1;
-	return (ret > 0)? 0 : ret;
+
+	ret = lls_deserialize_parse_result(aca->query.data, cmd, &aca->lpr);
+	assert(ret >= 0);
+	pmd.lpr = aca->lpr;
+	ret = for_each_matching_row(&pmd);
+	if (ret < 0)
+		goto out;
+	if (pmd.num_matches == 0)
+		ret = -E_NO_MATCH;
+out:
+	lls_free_parse_result(aca->lpr, cmd);
+	return ret;
 }
 
-static int com_catblob(callback_function *f, int fd, int argc,
-		char * const * const argv)
+static int com_catblob(afs_callback *f, const struct lls_command * const cmd,
+		struct command_context *cc, struct lls_parse_result *lpr)
 {
-	struct osl_object result;
-	int ret;
+	char *errctx;
+	int ret = lls(lls_check_arg_count(lpr, 1, INT_MAX, &errctx));
 
-	if (argc < 2)
-		return -E_BLOB_SYNTAX;
-	ret = send_standard_callback_request(argc - 1, argv + 1, f, &result);
-	if (ret > 0) {
-		ret = send_bin_buffer(fd, (char *)result.data, result.size);
-		free(result.data);
+	if (ret < 0) {
+		send_errctx(cc, errctx);
+		return ret;
 	}
-	return ret;
+	return send_lls_callback_request(f, cmd, lpr, cc);
 }
 
-struct rmblob_data {
-	struct para_buffer pb;
-	unsigned num_removed;
-};
-
 static int remove_blob(struct osl_table *table, struct osl_row *row,
 		const char *name, void *data)
 {
-	struct rmblob_data *rmbd = data;
-	int ret = osl_del_row(table, row);
+	struct afs_callback_arg *aca = data;
+	int ret = osl(osl_del_row(table, row));
+
 	if (ret < 0) {
-		para_printf(&rmbd->pb, "%s: %s\n", name, PARA_STRERROR(-ret));
+		para_printf(&aca->pbout, "cannot remove %s\n", name);
 		return ret;
 	}
-	rmbd->num_removed++;
-	return 1; /* return success to remove other matching blobs. */
+	return 1;
 }
 
-static int com_rmblob_callback(struct osl_table *table,
-		const struct osl_object *query,
-		__a_unused struct osl_object *result)
+static int com_rmblob_callback(const struct lls_command * const cmd,
+		struct osl_table *table, struct afs_callback_arg *aca)
 {
 	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,
-		.data = &rmbd,
+		.loop_col_num = BLOBCOL_NAME,
+		.match_col_num = BLOBCOL_NAME,
+		.pm_flags = PM_SKIP_EMPTY_NAME,
+		.data = aca,
 		.action = remove_blob
 	};
-	result->data = NULL;
-	ret = for_each_matching_blob(&bmd);
+
+	ret = lls_deserialize_parse_result(aca->query.data, cmd, &aca->lpr);
+	assert(ret >= 0);
+	pmd.lpr = aca->lpr;
+	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
-		para_printf(&rmbd.pb, "removed %d blobs\n", rmbd.num_removed);
-	result->data = rmbd.pb.buf;
-	result->size = rmbd.pb.size;
-	return 1;
+		goto out;
+	if (pmd.num_matches == 0)
+		ret = -E_NO_MATCH;
+	else {
+		para_printf(&aca->pbout, "removed %u blob(s)\n",
+			pmd.num_matches);
+		ret = afs_event(BLOB_REMOVE, NULL, table);
+	}
+out:
+	lls_free_parse_result(aca->lpr, cmd);
+	return ret;
 }
 
-static int com_rmblob(callback_function *f, __a_unused int fd, int argc,
-		char * const * const argv)
+static int com_rmblob(afs_callback *f, const struct lls_command * const cmd,
+		struct command_context *cc, struct lls_parse_result *lpr)
 {
-	int ret;
-	struct osl_object result;
-
-	if (argc < 2)
-		return -E_MOOD_SYNTAX;
-	ret = send_option_arg_callback_request(NULL, argc - 1, argv + 1, f,
-		&result);
-	if (ret > 0) {
-		send_buffer(fd, (char *)result.data);
-		free(result.data);
+	char *errctx;
+	int ret = lls(lls_check_arg_count(lpr, 1, INT_MAX, &errctx));
+
+	if (ret < 0) {
+		send_errctx(cc, errctx);
+		return ret;
 	}
-	return ret;
+	return send_lls_callback_request(f, cmd, lpr, cc);
 }
 
-static int com_addblob_callback(struct osl_table *table,
-		const struct osl_object *query,
-		__a_unused struct osl_object *result)
+static int com_addblob_callback(__a_unused const struct lls_command * const cmd,
+		struct osl_table *table, struct afs_callback_arg *aca)
 {
 	struct osl_object objs[NUM_BLOB_COLUMNS];
-	char *name = query->data;
+	char *name = aca->query.data;
 	size_t name_len = strlen(name) + 1;
-	uint32_t id;
+	uint32_t id = (uint32_t)-1; /* STFU, gcc */
+	char id_buf[sizeof(id)];
 	unsigned num_rows;
 	int ret;
 
-	ret = osl_get_num_rows(table, &num_rows);
+	ret = osl(osl_get_num_rows(table, &num_rows));
 	if (ret < 0)
-		return ret;
+		goto out;
 	if (!num_rows) { /* this is the first entry ever added */
-		/* insert dummy row containing the id */
-		id = 2; /* this entry will be entry #1, so 2 is the next */
-		objs[BLOBCOL_ID].data = &id;
-		objs[BLOBCOL_ID].size = sizeof(id);
+		/*
+		 * Insert dummy row containing the next free ID. Since we are
+		 * about to insert the first blob with ID 1, the next free ID
+		 * will be 2.
+		 */
+		id = 2U;
+		write_u32(id_buf, id);
+		objs[BLOBCOL_ID].data = id_buf;
+		objs[BLOBCOL_ID].size = sizeof(id_buf);
 		objs[BLOBCOL_NAME].data = "";
 		objs[BLOBCOL_NAME].size = 1;
 		objs[BLOBCOL_DEF].data = "";
 		objs[BLOBCOL_DEF].size = 1;
-		ret = osl_add_row(table, objs);
+		ret = osl(osl_add_row(table, objs));
 		if (ret < 0)
-			return ret;
+			goto out;
 	} else {
 		/* check if name already exists */
 		struct osl_row *row;
 		struct osl_object obj = {.data = name, .size = name_len};
-		ret = osl_get_row(table, BLOBCOL_NAME, &obj, &row);
-		if (ret < 0 && ret != -E_RB_KEY_NOT_FOUND)
-			return ret;
+		ret = osl(osl_get_row(table, BLOBCOL_NAME, &obj, &row));
+		if (ret < 0 && ret != -OSL_ERRNO_TO_PARA_ERROR(E_OSL_RB_KEY_NOT_FOUND))
+			goto out;
 		if (ret >= 0) { /* we already have a blob with this name */
+			ret = osl(osl_get_object(table, row, BLOBCOL_ID, &obj));
+			if (ret < 0)
+				goto out;
+			id = read_u32(obj.data);
 			obj.data = name + name_len;
-			obj.size = query->size - name_len;
-			return osl_update_object(table, row, BLOBCOL_DEF, &obj);
+			obj.size = aca->query.size - name_len;
+			ret = osl(osl_update_object(table, row, BLOBCOL_DEF, &obj));
+			goto out;
 		}
 		/* new blob, get id of the dummy row and increment it */
 		obj.data = "";
 		obj.size = 1;
-		ret = osl_get_row(table, BLOBCOL_NAME, &obj, &row);
+		ret = osl(osl_get_row(table, BLOBCOL_NAME, &obj, &row));
 		if (ret < 0)
-			return ret;
-		ret = osl_get_object(table, row, BLOBCOL_ID, &obj);
+			goto out;
+		ret = osl(osl_get_object(table, row, BLOBCOL_ID, &obj));
 		if (ret < 0)
-			return ret;
-		id = *(uint32_t *)obj.data + 1;
-		obj.data = &id;
-		ret = osl_update_object(table, row, BLOBCOL_ID, &obj);
+			goto out;
+		id = read_u32(obj.data) + 1;
+		write_u32(id_buf, id);
+		obj.data = &id_buf;
+		ret = osl(osl_update_object(table, row, BLOBCOL_ID, &obj));
 		if (ret < 0)
-			return ret;
+			goto out;
 	}
 	id--;
-	objs[BLOBCOL_ID].data = &id;
-	objs[BLOBCOL_ID].size = sizeof(id);
+	write_u32(id_buf, id);
+	objs[BLOBCOL_ID].data = &id_buf;
+	objs[BLOBCOL_ID].size = sizeof(id_buf);
 	objs[BLOBCOL_NAME].data = name;
 	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);
+	objs[BLOBCOL_DEF].size = aca->query.size - name_len;
+	ret = osl(osl_add_row(table, objs));
+	if (ret < 0)
+		goto out;
+	ret = afs_event(BLOB_ADD, NULL, table);
+out:
+	if (ret < 0)
+		para_printf(&aca->pbout, "cannot add %s\n", name);
+	else
+		para_printf(&aca->pbout, "added %s as id %u\n", name, id);
+	return ret;
 }
 
-static int com_addblob(callback_function *f, int fd, int argc,
-		char * const * const argv)
+/* Write input from fd to dynamically allocated buffer, but maximal 10M. */
+static int fd2buf(struct stream_cipher_context *scc, struct osl_object *obj)
 {
-	struct osl_object arg_obj;
+	size_t max_size = 10 * 1024 * 1024;
+	int ret;
+	struct iovec iov;
 
-	if (argc != 2)
-		return -E_BLOB_SYNTAX;
-	if (!*argv[1]) /* empty name is reserved for the dummy row */
-		return -E_BLOB_SYNTAX;
-	PARA_NOTICE_LOG("argv[1]: %s\n", argv[1]);
-	arg_obj.size = strlen(argv[1]) + 1;
-	arg_obj.data = (char *)argv[1];
-	return stdin_command(fd, &arg_obj, f, 10 * 1024 * 1024, NULL);
+	obj->data = NULL;
+	obj->size = 0;
+again:
+	do {
+		ret = recv_sb(scc, SBD_BLOB_DATA, max_size, &iov);
+	} while (ret == 0);
+
+	if (ret < 0) {
+		free(obj->data);
+		obj->data = NULL;
+		obj->size = 0;
+		return ret;
+	}
+	if (iov.iov_len == 0) /* end of blob */
+		return 1;
+	if (!obj->data) {
+		obj->data = iov.iov_base;
+		obj->size = iov.iov_len;
+	} else {
+		obj->data = para_realloc(obj->data, obj->size + iov.iov_len);
+		memcpy(obj->data + obj->size, iov.iov_base, iov.iov_len);
+		obj->size += iov.iov_len;
+		free(iov.iov_base);
+		max_size -= iov.iov_len;
+	}
+	goto again;
+	return 1;
 }
 
-static int com_mvblob_callback(struct osl_table *table,
-		const struct osl_object *query,
-		__a_unused struct osl_object *result)
+/*
+ * Read blob from a file descriptor and send it to afs.
+ *
+ * This function is called from the addblob command handlers to instruct the
+ * afs process to store the input in a blob table. Input is read and decrypted
+ * from the file descriptor given by cc and appended to a buffer which also contains
+ * the name of the blob to create. The combined buffer is made available to the
+ * afs process via the callback method.
+ */
+static int stdin_command(struct command_context *cc,
+		struct lls_parse_result *lpr, afs_callback *f)
 {
-	char *src = (char *) query->data;
-	struct osl_object obj = {.data = src, .size = strlen(src) + 1};
-	char *dest = src + obj.size;
-	struct osl_row *row;
-	int ret = osl_get_row(table, BLOBCOL_NAME, &obj, &row);
+	struct osl_object query, stdin_obj;
+	int ret;
+	size_t len = strlen(lls_input(0, lpr));
 
+	ret = send_sb(&cc->scc, NULL, 0, SBD_AWAITING_DATA, false);
 	if (ret < 0)
 		return ret;
-	obj.data = dest;
+	ret = fd2buf(&cc->scc, &stdin_obj);
+	if (ret < 0)
+		return ret;
+	query.size = len + 1 + stdin_obj.size;
+	query.data = para_malloc(query.size);
+	memcpy(query.data, lls_input(0, lpr), len + 1);
+	if (stdin_obj.size > 0)
+		memcpy((char *)query.data + len + 1, stdin_obj.data,
+			stdin_obj.size);
+	free(stdin_obj.data);
+	ret = send_callback_request(f, &query, afs_cb_result_handler, cc);
+	free(query.data);
+	return ret;
+}
+
+static int com_addblob(afs_callback *f, __a_unused const struct lls_command * const cmd,
+		struct command_context *cc, struct lls_parse_result *lpr)
+{
+	char *errctx;
+	int ret = lls(lls_check_arg_count(lpr, 1, 1, &errctx));
+
+	if (ret < 0) {
+		send_errctx(cc, errctx);
+		return ret;
+	}
+	if (!lls_input(0, lpr)[0]) /* empty name is reserved for the dummy row */
+		return -E_BLOB_SYNTAX;
+	return stdin_command(cc, lpr, f);
+}
+
+static int com_mvblob_callback(const struct lls_command * const cmd,
+		struct osl_table *table, struct afs_callback_arg *aca)
+{
+	const char *src, *dest;
+	struct osl_object obj;
+	struct osl_row *row;
+	int ret;
+
+	ret = lls_deserialize_parse_result(aca->query.data, cmd, &aca->lpr);
+	assert(ret >= 0);
+	src = lls_input(0, aca->lpr);
+	dest = lls_input(1, aca->lpr);
+	obj.data = (char *)src;
+	obj.size = strlen(src) + 1;
+	ret = osl(osl_get_row(table, BLOBCOL_NAME, &obj, &row));
+
+	if (ret < 0) {
+		para_printf(&aca->pbout, "cannot find source blob %s\n", src);
+		goto out;
+	}
+	obj.data = (char *)dest;
 	obj.size = strlen(dest) + 1;
-	return osl_update_object(table, row, BLOBCOL_NAME, &obj);
+	ret = osl(osl_update_object(table, row, BLOBCOL_NAME, &obj));
+	if (ret < 0) {
+		para_printf(&aca->pbout, "cannot rename blob %s to %s\n",
+			src, dest);
+		goto out;
+	}
+	ret = afs_event(BLOB_RENAME, NULL, table);
+out:
+	lls_free_parse_result(aca->lpr, cmd);
+	return ret;
 }
 
-static int com_mvblob(callback_function *f,  __a_unused int fd,
-		int argc, char * const * const argv)
+static int com_mvblob(afs_callback *f, const struct lls_command * const cmd,
+		struct command_context *cc, struct lls_parse_result *lpr)
 {
-	if (argc != 3)
-		return -E_MOOD_SYNTAX;
-	return send_option_arg_callback_request(NULL, argc - 1, argv + 1, f,
-		NULL);
+	char *errctx;
+	int ret = lls(lls_check_arg_count(lpr, 2, 2, &errctx));
+
+	if (ret < 0) {
+		send_errctx(cc, errctx);
+		return ret;
+	}
+	return send_lls_callback_request(f, cmd, lpr, cc);
 }
 
-#define DEFINE_BLOB_COMMAND(cmd_name, table_name, cmd_prefix) \
-	static int com_ ## cmd_name ## cmd_prefix ## _callback(const struct osl_object *query, \
-			struct osl_object *output) \
+#define DEFINE_BLOB_COMMAND(cmd_name, c_cmd_name, table_name, short_name, c_short_name) \
+	static int com_ ## cmd_name ## short_name ## _callback(struct afs_callback_arg *aca) \
 	{ \
-		return com_ ## cmd_name ## blob_callback(table_name ## _table, query, output); \
+		const struct lls_command *cmd = SERVER_CMD_CMD_PTR(c_cmd_name ## c_short_name); \
+		return com_ ## cmd_name ## blob_callback(cmd, table_name ## _table, aca); \
 	} \
-	int com_ ## cmd_name ## cmd_prefix(int fd, int argc, char * const * const argv) \
+	static int com_ ## cmd_name ## short_name(struct command_context *cc, struct lls_parse_result *lpr) \
 	{ \
-		return com_ ## cmd_name ## blob(com_ ## cmd_name ## cmd_prefix ## _callback, fd, argc, argv); \
-	}
+		const struct lls_command *cmd = SERVER_CMD_CMD_PTR(c_cmd_name ## c_short_name); \
+		return com_ ## cmd_name ## blob(com_ ## cmd_name ## short_name ## _callback, cmd, cc, lpr); \
+	} \
+	EXPORT_SERVER_CMD_HANDLER(cmd_name ## short_name);
 
 static int blob_get_name_by_id(struct osl_table *table, uint32_t id,
 		char **name)
@@ -432,16 +496,20 @@ static int blob_get_name_by_id(struct osl_table *table, uint32_t id,
 	struct osl_object obj = {.data = &id, .size = sizeof(id)};
 	int ret;
 
-	*name = NULL;
+	if (name)
+		*name = NULL;
 	if (!id)
 		return 1;
-	ret = osl_get_row(table, BLOBCOL_ID, &obj, &row);
+	ret = osl(osl_get_row(table, BLOBCOL_ID, &obj, &row));
 	if (ret < 0)
 		return ret;
-	ret = osl_get_object(table, row, BLOBCOL_NAME, &obj);
+	ret = osl(osl_get_object(table, row, BLOBCOL_NAME, &obj));
 	if (ret < 0)
 		return ret;
-	*name = (char *)obj.data;
+	if (*(char *)obj.data == '\0')
+		return -E_DUMMY_ROW;
+	if (name)
+		*name = (char *)obj.data;
 	return 1;
 }
 
@@ -452,15 +520,62 @@ 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(osl_get_row(table, BLOBCOL_NAME, &obj, &row));
+	if (ret < 0)
+		return ret;
+	return osl(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(osl_get_row(table, BLOBCOL_ID, &obj, &row));
+	if (ret < 0)
+		return ret;
+	return osl(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)
 {
 	struct osl_object obj;
-	int ret = osl_get_object(table, row, BLOBCOL_NAME, &obj);
+	int ret = osl(osl_get_object(table, row, BLOBCOL_NAME, &obj));
+
 	if (ret < 0)
 		return ret;
 	*name = obj.data;
-	return osl_open_disk_object(table, row, BLOBCOL_DEF, def);
+	return osl(osl_open_disk_object(table, row, BLOBCOL_DEF, def));
 }
 /** Define the \p get_name_and_def_by_row function for this blob type. */
 #define DEFINE_GET_NAME_AND_DEF_BY_ROW(table_name, cmd_prefix) \
@@ -471,52 +586,78 @@ 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) \
+	static 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) \
+	static int table_name ## _create(const char *dir) \
+	{ \
+		table_name ## _table_desc.dir = dir; \
+		return osl(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(osl_open_table(desc, table));
 	if (ret >= 0)
 		return ret;
 	*table = NULL;
-	return ret == -E_NOENT? 1 : ret;
+	if (ret >= 0 || ret == -OSL_ERRNO_TO_PARA_ERROR(E_OSL_NOENT))
+		return 1;
+	return ret;
 }
 
+#define DEFINE_BLOB_OPEN(table_name) \
+	static 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->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_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_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);
-DEFINE_BLOB_FUNCTIONS(images, img);
-DEFINE_BLOB_FUNCTIONS(moods, mood);
-DEFINE_BLOB_FUNCTIONS(playlists, pl);
-/** \endcond */
+#define DEFINE_BLOB_FUNCTIONS(table_name, short_name, c_short_name) \
+	DEFINE_BLOB_OPEN(table_name) \
+	DEFINE_BLOB_CLOSE(table_name) \
+	DEFINE_BLOB_CREATE(table_name) \
+	DEFINE_BLOB_INIT(table_name) \
+	DEFINE_BLOB_COMMAND(ls, LS, table_name, short_name, c_short_name) \
+	DEFINE_BLOB_COMMAND(cat, CAT, table_name, short_name, c_short_name) \
+	DEFINE_BLOB_COMMAND(add, ADD, table_name, short_name, c_short_name) \
+	DEFINE_BLOB_COMMAND(rm, RM, table_name, short_name, c_short_name) \
+	DEFINE_BLOB_COMMAND(mv, MV, table_name, short_name, c_short_name) \
+	DEFINE_GET_NAME_BY_ID(table_name, short_name); \
+	DEFINE_GET_DEF_BY_ID(table_name, short_name); \
+	DEFINE_GET_DEF_BY_NAME(table_name, short_name); \
+	DEFINE_GET_NAME_AND_DEF_BY_ROW(table_name, short_name); \
+
+/* doxygen isn't smart enough to recognize these */
+/** \cond blob_function */
+DEFINE_BLOB_FUNCTIONS(lyrics, lyr, LYR);
+DEFINE_BLOB_FUNCTIONS(images, img, IMG);
+DEFINE_BLOB_FUNCTIONS(moods, mood, MOOD);
+DEFINE_BLOB_FUNCTIONS(playlists, pl, PL);
+/** \endcond blob_function */