X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=blob.c;h=7aedf59bb9d3da7ead694f9c2d85c2d8e52da9d7;hp=2f17502143521db2b5178ea457e3149abb60a82f;hb=f167629b3191c57a6b691cd2a6af04a45a74ccb0;hpb=a092ce3940929f594d1f55d945cf43081706fb4b

diff --git a/blob.c b/blob.c
index 2f175021..7aedf59b 100644
--- a/blob.c
+++ b/blob.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2007-2013 Andre Noll <maan@systemlinux.org>
+ * Copyright (C) 2007 Andre Noll <maan@tuebingen.mpg.de>
  *
  * Licensed under the GPL v2. For licencing details see COPYING.
  */
@@ -311,12 +311,12 @@ static int com_rmblob(callback_function *f, struct command_context *cc)
 		afs_cb_result_handler, cc);
 }
 
-static void com_addblob_callback(struct osl_table *table, __a_unused int fd,
+static void com_addblob_callback(struct osl_table *table, int fd,
 		const struct osl_object *query)
 {
 	struct osl_object objs[NUM_BLOB_COLUMNS];
-	char *name = query->data;
-	size_t name_len = strlen(name) + 1;
+	char *name = query->data, *msg;
+	size_t name_len = strlen(name) + 1, msg_len;
 	uint32_t id;
 	unsigned num_rows;
 	int ret;
@@ -344,6 +344,10 @@ static void com_addblob_callback(struct osl_table *table, __a_unused int fd,
 		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 = *(uint32_t *)obj.data;
 			obj.data = name + name_len;
 			obj.size = query->size - name_len;
 			ret = osl(osl_update_object(table, row, BLOBCOL_DEF, &obj));
@@ -377,81 +381,88 @@ static void com_addblob_callback(struct osl_table *table, __a_unused int fd,
 	afs_event(BLOB_ADD, NULL, table);
 out:
 	if (ret < 0)
-		PARA_NOTICE_LOG("%s\n", para_strerror(-ret));
+		msg_len = xasprintf(&msg, "could not add %s: %s\n", name,
+			para_strerror(-ret));
+	else
+		msg_len = xasprintf(&msg, "added %s as id %u\n", name, id);
+	pass_buffer_as_shm(fd, SBD_OUTPUT, msg, msg_len);
+	free(msg);
 }
 
-/*
- * write input from fd to dynamically allocated buffer,
- * but maximal max_size byte.
- */
-static int fd2buf(struct stream_cipher_context *scc, unsigned max_size, struct osl_object *obj)
+/* Write input from fd to dynamically allocated buffer, but maximal 10M. */
+static int fd2buf(struct stream_cipher_context *scc, struct osl_object *obj)
 {
-	const size_t chunk_size = 1024;
-	size_t size = 2048, received = 0;
+	size_t max_size = 10 * 1024 * 1024;
 	int ret;
-	char *buf = para_malloc(size);
+	struct iovec iov;
 
-	for (;;) {
-		ret = sc_recv_bin_buffer(scc, buf + received, chunk_size);
-		if (ret <= 0)
-			break;
-		received += ret;
-		if (received + chunk_size >= size) {
-			size *= 2;
-			ret = -E_INPUT_TOO_LARGE;
-			if (size > max_size)
-				break;
-			buf = para_realloc(buf, size);
-		}
+	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;
 	}
-	obj->data = buf;
-	obj->size = received;
-	if (ret < 0)
-		free(buf);
-	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;
 }
 
 /*
  * Read data from a file descriptor, and send it to the afs process.
  *
- * \param scc crypt context containing the file descriptor to read data from.
+ * \param cc Contains the file descriptor to read data from.
  * \param arg_obj Pointer to the arguments to \a f.
  * \param f The callback function.
- * \param max_len Don't read more than that many bytes from stdin.
  * \param result_handler See \ref send_callback_request.
  * \param private_result_data See \ref send_callback_request.
  *
- * This function is used by commands that wish to let para_server store
- * arbitrary data specified by the user (for instance the add_blob family of
- * commands). First, at most \a max_len bytes are read and decrypted from the
- * file descriptor given by \a scc. The result is concatenated with the buffer
- * given by \a arg_obj, and the combined buffer is made available to the afs
- * process via the callback method. See \ref send_callback_request for details.
+ * This function is used by the addblob commands that instruct para_server to
+ * store arbitrary data in a blob table. Input data is read and decrypted from
+ * the file descriptor given by \a cc. This data is concatenated with the
+ * buffer given by \a arg_obj, and the combined buffer is made available to the
+ * afs process via the callback method. See \ref send_callback_request for
+ * details.
  *
  * \return Negative on errors, the return value of the underlying call to
  * send_callback_request() otherwise.
  */
 static int stdin_command(struct command_context *cc, struct osl_object *arg_obj,
-		callback_function *f, unsigned max_len,
-		callback_result_handler *result_handler,
+		callback_function *f, callback_result_handler *result_handler,
 		void *private_result_data)
 {
 	struct osl_object query, stdin_obj;
 	int ret;
 
-	if (cc->use_sideband)
-		ret = send_sb(&cc->scc, NULL, 0, SBD_AWAITING_DATA, false);
-	else
-		ret = sc_send_buffer(&cc->scc, AWAITING_DATA_MSG);
+	ret = send_sb(&cc->scc, NULL, 0, SBD_AWAITING_DATA, false);
 	if (ret < 0)
 		return ret;
-	ret = fd2buf(&cc->scc, max_len, &stdin_obj);
+	ret = fd2buf(&cc->scc, &stdin_obj);
 	if (ret < 0)
 		return ret;
 	query.size = arg_obj->size + stdin_obj.size;
 	query.data = para_malloc(query.size);
 	memcpy(query.data, arg_obj->data, arg_obj->size);
-	memcpy((char *)query.data + arg_obj->size, stdin_obj.data, stdin_obj.size);
+	if (stdin_obj.size > 0)
+		memcpy((char *)query.data + arg_obj->size, stdin_obj.data,
+			stdin_obj.size);
 	free(stdin_obj.data);
 	ret = send_callback_request(f, &query, result_handler, private_result_data);
 	free(query.data);
@@ -468,38 +479,54 @@ static int com_addblob(callback_function *f, struct command_context *cc)
 		return -E_BLOB_SYNTAX;
 	arg_obj.size = strlen(cc->argv[1]) + 1;
 	arg_obj.data = (char *)cc->argv[1];
-	return stdin_command(cc, &arg_obj, f, 10 * 1024 * 1024, NULL, NULL);
+	return stdin_command(cc, &arg_obj, f, afs_cb_result_handler, cc);
 }
 
-/* FIXME: Print output to client, not to log file */
-static void com_mvblob_callback(struct osl_table *table, __a_unused int fd,
+static void com_mvblob_callback(struct osl_table *table, int fd,
 		const struct osl_object *query)
 {
 	char *src = (char *) query->data;
 	struct osl_object obj = {.data = src, .size = strlen(src) + 1};
 	char *dest = src + obj.size;
 	struct osl_row *row;
+	struct para_buffer pb = {
+		.max_size = shm_get_shmmax(),
+		.private_data = &fd,
+		.max_size_handler = afs_max_size_handler
+	};
 	int ret = osl(osl_get_row(table, BLOBCOL_NAME, &obj, &row));
 
-	if (ret < 0)
+	if (ret < 0) {
+		para_printf(&pb, "could not locate %s: %s\n", src,
+			para_strerror(-ret));
 		goto out;
+	}
 	obj.data = dest;
 	obj.size = strlen(dest) + 1;
 	ret = osl(osl_update_object(table, row, BLOBCOL_NAME, &obj));
-	if (ret < 0)
+	if (ret < 0) {
+		para_printf(&pb, "failed to update object %s: %s\n", dest,
+			para_strerror(-ret));
 		goto out;
+	}
 	afs_event(BLOB_RENAME, NULL, table);
 out:
-	if (ret < 0)
-		PARA_NOTICE_LOG("%s\n", para_strerror(-ret));
+	if (pb.offset)
+		pass_buffer_as_shm(fd, SBD_OUTPUT, pb.buf, pb.offset);
+	free(pb.buf);
 }
 
 static int com_mvblob(callback_function *f, struct command_context *cc)
 {
+	int ret;
+
 	if (cc->argc != 3)
 		return -E_MOOD_SYNTAX;
-	return send_option_arg_callback_request(NULL, cc->argc - 1,
-		cc->argv + 1, f, NULL, NULL);
+	ret = send_option_arg_callback_request(NULL, cc->argc - 1,
+		cc->argv + 1, f, afs_cb_result_handler, cc);
+	if (ret < 0)
+		send_strerror(cc, -ret);
+	return ret;
 }
 
 #define DEFINE_BLOB_COMMAND(cmd_name, table_name, cmd_prefix) \