...

diff --git a/inc/block.h b/inc/block.h
index 8ca3d802f0d5e2f58c46bee70e2de638afb532f1..fa7496d454b00d4ff8ca89739f95c7af16800158 100644 (file)
--- a/inc/block.h
+++ b/inc/block.h
@@ -21,5 +21,6 @@ int block_init(struct block**);
 size_t block_length(struct block*);
 int block_merkle_layer(struct block*);
 int block_merkle_root(struct block*);
+int block_pad(struct block*);
 
 #endif

diff --git a/src/block.c b/src/block.c
index 67518643d2a27acb873ecb06d42b53adda6279a9..4c6706257b3f56143ec30d3ad7de16839d21a101 100644 (file)
--- a/src/block.c
+++ b/src/block.c
@@ -114,6 +114,21 @@ int block_merkle_root(struct block *root) {
        return 1;
 }
 
-int block_pad(struct block *root) {
-       return -1;
+int block_pad(struct block *p) {
+       if(NULL==p) { return -1; }
+
+       size_t i = 1;
+       while(p->next!=NULL) {
+               i++;
+               p = p->next;
+       }
+
+       while(i&&(i&(i-1))) {
+               if(block_init(&(p->next))<0) { return -1; }
+               memset(p->next->hash,0,crypto_hash_sha256_BYTES);
+               p = p->next;
+               i++;
+       }
+
+       return 1;
 }

diff --git a/src/file.c b/src/file.c
index 2810dcbf9c251257c131f715c46b300d5215ccfd..9dc7a58d0d8ea5f6a5419b8ba0ba1dfa20f54c0c 100644 (file)
--- a/src/file.c
+++ b/src/file.c
@@ -20,8 +20,10 @@ void file_free(struct file *p) {
 
 int file_hash(struct file *file_p, int piece_length) {
        uint8_t data[BLOCK_SIZE];
-       struct block *p, *next;
+       struct block *p, *next, *layer_p;
        FILE *fp;
+       size_t blocks;
+       int ratio;
 
        if(NULL==file_p) { return -1; }
 
@@ -36,6 +38,9 @@ int file_hash(struct file *file_p, int piece_length) {
                return -1;
        }
 
+       blocks = 0;
+       ratio = piece_length / BLOCK_SIZE;
+
        /* generate piece_layers
         * 1. grab all data and hash
         * 2. generate piece layer merkle trees (padding to piece layer boundary)
@@ -59,18 +64,25 @@ int file_hash(struct file *file_p, int piece_length) {
                if(NULL==p) {
                        file_p->piece_layers = next;
                        p = next;
+                       layer_p = next;
                } else {
                        p->next = next;
                        p = p->next;
                }
+
+               if(blocks%ratio==0) {
+                       layer_p = p;
+               }
+
+               blocks++;
        }
 
        fclose(fp);
 
        // pad to appropiate piece layer size
        // i.e. so each piece layer tree is balanced
+       if(block_pad(layer_p)<0) { return -1; }
 
-       int ratio = piece_length / BLOCK_SIZE;
        while(ratio>1) {
                if(block_merkle_layer(file_p->piece_layers)<0) { return -1; }
                ratio>>=1;

diff --git a/test/unit/block.tests.c b/test/unit/block.tests.c
index 36804afdaf4117d7ae1aab043855eb527a6d50ba..dffd667dbb160035c502b69c45e8af1e99708b72 100644 (file)
--- a/test/unit/block.tests.c
+++ b/test/unit/block.tests.c
@@ -8,6 +8,7 @@ static void block_init_basic_test();
 static void block_length_basic_test();
 static void block_merkle_layer_basic_test();
 static void block_merkle_root_basic_test();
+static void block_pad_basic_test();
 
 int main() {
        setup_env();
@@ -17,6 +18,7 @@ int main() {
        block_length_basic_test();
        block_merkle_layer_basic_test();
        block_merkle_root_basic_test();
+       block_pad_basic_test();
 
        clean_env();
 
@@ -173,3 +175,34 @@ static void block_merkle_root_basic_test() {
 
        block_free(root);
 }
+
+static void block_pad_basic_test() {
+       struct block *root, *p;
+
+       assert(-1==block_pad(NULL));
+
+       assert(block_init(&root)==1);
+       assert(block_pad(root)==1);
+       assert(block_length(root)==1);
+
+       assert(block_init(&(root->next))==1);
+       assert(block_pad(root)==1);
+       assert(block_length(root)==2);
+
+       p = root->next;
+       for(size_t i=2;i<7;i++) {
+               assert(block_init(&(p->next))==1);
+               p = p->next;
+       }
+
+       assert(block_length(root)==7);
+       for(size_t i=8;i<=1024;i<<=1) {
+               assert(block_pad(root)==1);
+               assert(block_length(root)==i);
+       
+               assert(block_pad(root->next)==1);
+               assert(block_length(root)==i+1);
+       }
+
+       block_free(root);
+}