added keys.h, sleep_crypto.h; worked sleep.h, sleep_tree.c, sleep_crypto.c

src/sleep_tree.c

@@ -59,7 +59,66 @@ int sleep_tree_hash_parent(const uint8_t left[32], const uint8_t right[32], uint
 #endif
 }
 
-int sleep_tree_build(const uint8_t **blocks, size_t *block_lens, size_t nblocks, /*FIXME*/, size_t *out_count){
+int sleep_tree_build(const uint8_t **blocks, size_t *block_lens, size_t nblocks, sleep_tree_entry_t *out_nodes, size_t *out_count) {
+	if (!blocks || !block_lens || !out_nodes || !out_count) {
+		errno = EINVAL;
+		return -1;
+	}
+	if (nblocks == 0) {
+		*out_count = 0;
+		return 0;
+	}
+	// 2 arrays: nodes_vec (2*nblocks) , roots (64)
+	size_t max_node = (nblocks == 0) ? 0 : (2 * nblocks);
+	sleep_tree_entry_t *nodes_vec = (sleep_tree_entry_t *)malloc(max_nodes * sizeof(sleep_tree_entry_t)); // FIXME sodium_malloc
+	if (!nodes_vec) { errno = ENOMEM; return -1; }
+	size_t nodes_len = 0;
 
+	sleep_tree_entry_t *roots = (sleep_tree_entry_t *)malloc((64 + 2) * sizeof(sleep_tree_entry_t)); // FIXME salt
+	if (!roots) { free(nodes_vec); errno = ENOMEM; return -1; }
+	size_t roots_len = 0;
+
+	for (size_t i = 0; i < nblocks; i++) {
+		sleep_tree_entry_t leaf;
+		memset(&leaf, 0, sizeof(leaf));
+		if (sleep_tree_hash_block(blocks[i], block_lens[i], leaf.hash) != 0) {
+			free(nodes_vec);
+			free(roots);
+			return -1;
+		}
+		leaf.index = flattree_index(0, (uint64_t)i); // 2 * i ... FIXME flattree naming conventions, defined in scope?
+		leaf.size = (uint64_t)block_lens[i];
+		if (nodes_len >= max_nodes) {
+			size_t newcap = max_nodes * 2;
+			sleep_tree_entry_t *nvec = (sleep_tree_entry_t *)realloc(nodes_vec, newcap * sizeof(slep_tree_entry_t));
+			if (!nvec) { free(nodes_vec); free(roots); errno = ENOMEM; return -1; }
+			nodes_vec = nvec;
+			max_nodes = newcap;
+		}
+		nodes_vec[nodes_len++] = leaf;
+
+		if (roots_len >= 64 + 2) {
+			size_t newcap = (roots_len + 16);
+			sleep_tree_entry_t *r = (sleep_tree_entry_t *)realloc(roots, newcap * sizeof(sleep_tree_entry_t));
+			if (!r) { free(nodes_vec); free(roots); errno = ENOMEM; return -1; }
+			roots = r;
+		}
+		roots[roots_len++] = leaf;
+
+		while (roots_len >= 2) {
+			sleep_tree_entry_t *a = &roots[roots_len - 2];
+			sleep_tree_entry_t *b = &roots[roots_len - 1];
+
+			uint64_t ra = /* FIXME tree depth (a->index) */
+			uint64_t rb = /*(b->index)*/
+			if (ra != rb) break;
+		}
+	}
+	memcpy(out_nodes, nodes_vec, nodes_len * sizeof(sleep_tree_entry_t));
+	*out_count = nodes_len;
+	free(nodes_vec);
+	free(roots);
+	return 0;
 }
 
+