X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=buffer_tree.c;h=1c4e046ad8f2aa478bcd4eaf5d94171f0224fd63;hp=5c884709bab83407fa3f90bcc13bfc1c1b9b7550;hb=0eb69b6d45c54deda1724b2db2202cf4057b0309;hpb=4ac3134c050ba28b57e0ae9686eb1f6d83e6d586

diff --git a/buffer_tree.c b/buffer_tree.c
index 5c884709..1c4e046a 100644
--- a/buffer_tree.c
+++ b/buffer_tree.c
@@ -30,6 +30,8 @@ struct btr_buffer {
 	int refcount;
 	/* NULL means no buffer pool but a malloced buffer. */
 	struct btr_pool *pool;
+	/* Only relevant if pool is NULL. */
+	bool dont_free;
 };
 
 struct btr_buffer_reference {
@@ -293,9 +295,10 @@ struct btr_node *btr_new_node(struct btr_node_description *bnd)
 		bnd->child->parent = btrn;
 		goto out;
 	}
-	PARA_EMERG_LOG("inserting internal nodes not yet supported.\n");
-	exit(EXIT_FAILURE);
-	assert(bnd->child->parent == bnd->parent);
+	list_add_tail(&btrn->node, &bnd->parent->children);
+	list_move(&bnd->child->node, &btrn->children);
+	bnd->child->parent = btrn;
+	PARA_INFO_LOG("added %s as internal node\n", bnd->name);
 out:
 	return btrn;
 }
@@ -319,7 +322,7 @@ static void dealloc_buffer(struct btr_buffer *btrb)
 {
 	if (btrb->pool)
 		btr_pool_deallocate(btrb->pool, btrb->size);
-	else
+	else if (!btrb->dont_free)
 		free(btrb->buf);
 }
 
@@ -392,6 +395,34 @@ void btr_add_output(char *buf, size_t size, struct btr_node *btrn)
 	add_btrb_to_children(btrb, btrn, 0);
 }
 
+/**
+ * Insert a buffer into the buffer tree, non-freeing variant.
+ *
+ * \param buf See \ref btr_add_output().
+ * \param size See \ref btr_add_output().
+ * \param btrn See \ref btr_add_output().
+ *
+ * This is similar to btr_add_output() but additionally sets the \p dont_free
+ * flag on \a buf. If the refcount for the buffer drops to zero, \a buf will
+ * not be deallocated if this flag is set.
+ *
+ * The \p dont_free bit also prevents the children of \a btrn from modifying
+ * the buffer contents inplace. Specifically, \ref btr_inplace_ok() returns
+ * false if there is any buffer in the input queue with the \p dont_free bit
+ * set.
+ */
+void btr_add_output_dont_free(const char *buf, size_t size, struct btr_node *btrn)
+{
+	struct btr_buffer *btrb;
+
+	assert(size != 0);
+	if (list_empty(&btrn->children))
+		return;
+	btrb = new_btrb((char *)buf, size);
+	btrb->dont_free = true;
+	add_btrb_to_children(btrb, btrn, 0);
+}
+
 /**
  * Feed data to child nodes of a buffer tree node.
  *
@@ -544,9 +575,15 @@ bool btr_no_parent(struct btr_node *btrn)
  */
 bool btr_inplace_ok(struct btr_node *btrn)
 {
-	if (!btrn->parent)
-		return true;
-	return list_is_singular(&btrn->parent->children);
+	struct btr_buffer_reference *br;
+	FOR_EACH_BUFFER_REF(br, btrn) {
+		struct btr_buffer *btrb = br->btrb;
+		if (btrb->refcount > 1)
+			return false;
+		if (btrb->dont_free == true)
+			return false;
+	}
+	return true;
 }
 
 static inline size_t br_available_bytes(struct btr_buffer_reference *br)
@@ -566,7 +603,7 @@ static size_t btr_get_buffer_by_reference(struct btr_buffer_reference *br, char
  *
  * \param btrn The node whose input queue is to be queried.
  * \param omit Number of bytes to be omitted.
- * \param bufp Result pointer.
+ * \param bufp Result pointer. It is OK to pass \p NULL here.
  *
  * If a buffer tree node needs more input data but can not consume the data it
  * already has (because it might be needed again later) this function can be
@@ -842,37 +879,36 @@ size_t btr_get_output_queue_size(struct btr_node *btrn)
 }
 
 /**
- * Execute a inter-node command on a parent node.
+ * Execute an inter-node command on the given node or on a parent node.
  *
  * \param btrn The node to start looking.
  * \param command The command to execute.
  * \param value_result Additional arguments and result value.
  *
- * This function traverses the buffer tree upwards and looks for parent nodes
- * of \a btrn that understands \a command. On the first such node the command
- * is executed, and the result is stored in \a value_result.
+ * This function traverses the buffer tree from \a btrn upwards and looks for
+ * the first node that understands \a command. On this node \a command is
+ * executed, and the result is stored in \a value_result.
  *
  * \return \p -ENOTSUP if no parent node of \a btrn understands \a command.
  * Otherwise the return value of the command handler is returned.
+ *
+ * \sa \ref receiver::execute, filter::execute, writer::execute.
  */
 int btr_exec_up(struct btr_node *btrn, const char *command, char **value_result)
 {
 	int ret;
 
 	for (; btrn; btrn = btrn->parent) {
-		struct btr_node *parent = btrn->parent;
-		if (!parent)
-			return -ERRNO_TO_PARA_ERROR(ENOTSUP);
-		if (!parent->execute)
+		if (!btrn->execute)
 			continue;
-		PARA_INFO_LOG("parent: %s, cmd: %s\n", parent->name, command);
-		ret = parent->execute(parent, command, value_result);
+		PARA_INFO_LOG("executing %s on %s\n", command, btrn->name);
+		ret = btrn->execute(btrn, command, value_result);
 		if (ret == -ERRNO_TO_PARA_ERROR(ENOTSUP))
 			continue;
 		if (ret < 0)
 			return ret;
 		if (value_result && *value_result)
-			PARA_INFO_LOG("%s(%s): %s\n", command, parent->name,
+			PARA_INFO_LOG("%s(%s): %s\n", command, btrn->name,
 				*value_result);
 		return 1;
 	}
@@ -1190,3 +1226,8 @@ void btr_get_node_start(struct btr_node *btrn, struct timeval *tv)
 {
 	*tv = btrn->start;
 }
+
+struct btr_node *btr_parent(struct btr_node *btrn)
+{
+	return btrn->parent;
+}